@everworker/oneringai 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -5,6 +5,8 @@ var jose = require('jose');
 var fs16 = require('fs');
 var eventemitter3 = require('eventemitter3');
 var path2 = require('path');
+var TurndownService = require('turndown');
+var readability = require('@mozilla/readability');
 var os2 = require('os');
 var OpenAI3 = require('openai');
 var Anthropic = require('@anthropic-ai/sdk');
@@ -12,6 +14,7 @@ var genai = require('@google/genai');
 require('zod/v3');
 var z4mini = require('zod/v4-mini');
 var z = require('zod/v4');
+var spawn = require('cross-spawn');
 var process2 = require('process');
 var stream = require('stream');
 var fs15 = require('fs/promises');
@@ -19,8 +22,6 @@ var simpleIcons = require('simple-icons');
 var child_process = require('child_process');
 var util = require('util');
 var cheerio = require('cheerio');
-var TurndownService = require('turndown');
-var readability = require('@mozilla/readability');
 var vm = require('vm');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -46,15 +47,16 @@ function _interopNamespace(e) {
 var crypto2__namespace = /*#__PURE__*/_interopNamespace(crypto2);
 var fs16__namespace = /*#__PURE__*/_interopNamespace(fs16);
 var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
+var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
 var os2__namespace = /*#__PURE__*/_interopNamespace(os2);
 var OpenAI3__default = /*#__PURE__*/_interopDefault(OpenAI3);
 var Anthropic__default = /*#__PURE__*/_interopDefault(Anthropic);
 var z4mini__namespace = /*#__PURE__*/_interopNamespace(z4mini);
 var z__namespace = /*#__PURE__*/_interopNamespace(z);
+var spawn__default = /*#__PURE__*/_interopDefault(spawn);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
 var fs15__namespace = /*#__PURE__*/_interopNamespace(fs15);
 var simpleIcons__namespace = /*#__PURE__*/_interopNamespace(simpleIcons);
-var TurndownService__default = /*#__PURE__*/_interopDefault(TurndownService);
 var vm__namespace = /*#__PURE__*/_interopNamespace(vm);
 
 var __create = Object.create;
@@ -2262,6 +2264,66 @@ var init_Connector = __esm({
   }
 });
 
+// src/core/constants.ts
+var AGENT_DEFAULTS, TOKEN_ESTIMATION, DOCUMENT_DEFAULTS;
+var init_constants = __esm({
+  "src/core/constants.ts"() {
+    AGENT_DEFAULTS = {
+      /** Default maximum iterations for agentic loop */
+      MAX_ITERATIONS: 50,
+      /** Default temperature for LLM calls */
+      DEFAULT_TEMPERATURE: 0.7,
+      /** Message injected when max iterations is reached */
+      MAX_ITERATIONS_MESSAGE: `You have reached the maximum iteration limit for this execution. Please:
+1. Summarize what you have accomplished so far
+2. Explain what remains to be done (if anything)
+3. Ask the user if they would like you to continue
+
+Do NOT use any tools in this response - just provide a clear summary and ask for confirmation to proceed.`
+    };
+    TOKEN_ESTIMATION = {
+      /** Characters per token for code */
+      CODE_CHARS_PER_TOKEN: 3,
+      /** Characters per token for prose */
+      PROSE_CHARS_PER_TOKEN: 4,
+      /** Characters per token for mixed content */
+      MIXED_CHARS_PER_TOKEN: 3.5,
+      /** Default characters per token */
+      DEFAULT_CHARS_PER_TOKEN: 4
+    };
+    DOCUMENT_DEFAULTS = {
+      /** Maximum estimated tokens in output */
+      MAX_OUTPUT_TOKENS: 1e5,
+      /** Maximum output size in bytes (5MB) */
+      MAX_OUTPUT_BYTES: 5 * 1024 * 1024,
+      /** Maximum download size for URL sources (50MB) */
+      MAX_DOWNLOAD_SIZE_BYTES: 50 * 1024 * 1024,
+      /** Download timeout for URL sources */
+      DOWNLOAD_TIMEOUT_MS: 6e4,
+      /** Maximum extracted images from a single document */
+      MAX_EXTRACTED_IMAGES: 50,
+      /** Maximum Excel rows per sheet */
+      MAX_EXCEL_ROWS: 1e3,
+      /** Maximum Excel columns per sheet */
+      MAX_EXCEL_COLUMNS: 50,
+      /** Maximum HTML content length */
+      MAX_HTML_LENGTH: 5e4,
+      /** Characters per token estimate */
+      CHARS_PER_TOKEN: 4,
+      /** Estimated tokens for an image with auto detail */
+      IMAGE_TOKENS_AUTO: 765,
+      /** Estimated tokens for an image with low detail */
+      IMAGE_TOKENS_LOW: 85,
+      /** Image filter defaults */
+      IMAGE_FILTER: {
+        MIN_WIDTH: 50,
+        MIN_HEIGHT: 50,
+        MIN_SIZE_BYTES: 1024
+      }
+    };
+  }
+});
+
 // node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
   "node_modules/@modelcontextprotocol/sdk/node_modules/ajv/dist/compile/codegen/code.js"(exports$1) {
@@ -14575,491 +14637,961 @@ var require_dist = __commonJS({
   }
 });
 
-// node_modules/isexe/windows.js
-var require_windows = __commonJS({
-  "node_modules/isexe/windows.js"(exports$1, module) {
-    module.exports = isexe;
-    isexe.sync = sync;
-    var fs17 = __require("fs");
-    function checkPathExt(path6, options) {
-      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
-      if (!pathext) {
-        return true;
-      }
-      pathext = pathext.split(";");
-      if (pathext.indexOf("") !== -1) {
-        return true;
+// src/capabilities/documents/handlers/TextHandler.ts
+var CODE_FENCE_FORMATS, TextHandler;
+var init_TextHandler = __esm({
+  "src/capabilities/documents/handlers/TextHandler.ts"() {
+    init_constants();
+    CODE_FENCE_FORMATS = {
+      json: "json",
+      xml: "xml",
+      yaml: "yaml",
+      yml: "yaml"
+    };
+    TextHandler = class {
+      name = "TextHandler";
+      supportedFormats = ["txt", "md", "json", "xml", "yaml", "yml"];
+      async handle(buffer, filename, format, _options) {
+        const text = buffer.toString("utf-8");
+        const fenceLanguage = CODE_FENCE_FORMATS[format];
+        const content = fenceLanguage ? `\`\`\`${fenceLanguage}
+${text}
+\`\`\`` : text;
+        const sizeBytes = Buffer.byteLength(content, "utf-8");
+        return [
+          {
+            type: "text",
+            content,
+            metadata: {
+              sourceFilename: filename,
+              format,
+              index: 0,
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+            }
+          }
+        ];
       }
-      for (var i = 0; i < pathext.length; i++) {
-        var p = pathext[i].toLowerCase();
-        if (p && path6.substr(-p.length).toLowerCase() === p) {
-          return true;
+    };
+  }
+});
+
+// src/capabilities/documents/handlers/ImageHandler.ts
+var MIME_TYPES, ImageHandler;
+var init_ImageHandler = __esm({
+  "src/capabilities/documents/handlers/ImageHandler.ts"() {
+    init_constants();
+    MIME_TYPES = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml"
+    };
+    ImageHandler = class {
+      name = "ImageHandler";
+      supportedFormats = ["png", "jpg", "jpeg", "gif", "webp", "svg"];
+      async handle(buffer, filename, format, _options) {
+        const pieces = [];
+        const mimeType = MIME_TYPES[format] || "application/octet-stream";
+        pieces.push({
+          type: "image",
+          base64: buffer.toString("base64"),
+          mimeType,
+          metadata: {
+            sourceFilename: filename,
+            format,
+            index: 0,
+            sizeBytes: buffer.length,
+            estimatedTokens: DOCUMENT_DEFAULTS.IMAGE_TOKENS_AUTO,
+            label: filename
+          }
+        });
+        if (format === "svg") {
+          const svgText = buffer.toString("utf-8");
+          const sizeBytes = Buffer.byteLength(svgText, "utf-8");
+          pieces.push({
+            type: "text",
+            content: `\`\`\`svg
+${svgText}
+\`\`\``,
+            metadata: {
+              sourceFilename: filename,
+              format,
+              index: 1,
+              section: "SVG source",
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+            }
+          });
         }
+        return pieces;
       }
-      return false;
-    }
-    function checkStat(stat6, path6, options) {
-      if (!stat6.isSymbolicLink() && !stat6.isFile()) {
-        return false;
-      }
-      return checkPathExt(path6, options);
-    }
-    function isexe(path6, options, cb) {
-      fs17.stat(path6, function(er, stat6) {
-        cb(er, er ? false : checkStat(stat6, path6, options));
-      });
-    }
-    function sync(path6, options) {
-      return checkStat(fs17.statSync(path6), path6, options);
-    }
+    };
   }
 });
-
-// node_modules/isexe/mode.js
-var require_mode = __commonJS({
-  "node_modules/isexe/mode.js"(exports$1, module) {
-    module.exports = isexe;
-    isexe.sync = sync;
-    var fs17 = __require("fs");
-    function isexe(path6, options, cb) {
-      fs17.stat(path6, function(er, stat6) {
-        cb(er, er ? false : checkStat(stat6, options));
-      });
-    }
-    function sync(path6, options) {
-      return checkStat(fs17.statSync(path6), options);
+async function getJSDOM() {
+  if (!JSDOM) {
+    const jsdom = await import('jsdom');
+    JSDOM = jsdom.JSDOM;
+  }
+  return JSDOM;
+}
+async function htmlToMarkdown(html, url2, maxLength = 5e4) {
+  const JSDOMClass = await getJSDOM();
+  const dom = new JSDOMClass(html, { url: url2 });
+  const document = dom.window.document;
+  let title = document.title || "";
+  let byline;
+  let excerpt;
+  let contentHtml = html;
+  let wasReadabilityUsed = false;
+  try {
+    const clonedDoc = document.cloneNode(true);
+    const reader = new readability.Readability(clonedDoc);
+    const article = reader.parse();
+    if (article && article.content && article.content.length > 100) {
+      contentHtml = article.content;
+      title = article.title || title;
+      byline = article.byline || void 0;
+      excerpt = article.excerpt || void 0;
+      wasReadabilityUsed = true;
     }
-    function checkStat(stat6, options) {
-      return stat6.isFile() && checkMode(stat6, options);
+  } catch {
+  }
+  const turndown = new TurndownService__default.default({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+    emDelimiter: "_"
+  });
+  turndown.remove(["script", "style", "nav", "footer", "aside", "iframe", "noscript"]);
+  turndown.addRule("pre", {
+    filter: ["pre"],
+    replacement: (content, node) => {
+      const element = node;
+      const code = element.querySelector?.("code");
+      const lang = code?.className?.match(/language-(\w+)/)?.[1] || "";
+      const text = code?.textContent || content;
+      return `
+\`\`\`${lang}
+${text}
+\`\`\`
+`;
     }
-    function checkMode(stat6, options) {
-      var mod = stat6.mode;
-      var uid = stat6.uid;
-      var gid = stat6.gid;
-      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
-      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
-      var u = parseInt("100", 8);
-      var g = parseInt("010", 8);
-      var o = parseInt("001", 8);
-      var ug = u | g;
-      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
-      return ret;
+  });
+  let markdown = turndown.turndown(contentHtml);
+  markdown = markdown.replace(/\n{3,}/g, "\n\n").replace(/^\s+|\s+$/g, "").replace(/[ \t]+$/gm, "");
+  let wasTruncated = false;
+  if (markdown.length > maxLength) {
+    const truncateAt = markdown.lastIndexOf("\n\n", maxLength);
+    if (truncateAt > maxLength * 0.5) {
+      markdown = markdown.slice(0, truncateAt) + "\n\n...[content truncated]";
+    } else {
+      markdown = markdown.slice(0, maxLength) + "...[truncated]";
     }
+    wasTruncated = true;
+  }
+  return {
+    markdown,
+    title,
+    byline,
+    excerpt,
+    wasReadabilityUsed,
+    wasTruncated
+  };
+}
+var JSDOM;
+var init_htmlToMarkdown = __esm({
+  "src/tools/web/htmlToMarkdown.ts"() {
+    JSDOM = null;
+  }
+});
+
+// src/capabilities/documents/handlers/HTMLHandler.ts
+var HTMLHandler;
+var init_HTMLHandler = __esm({
+  "src/capabilities/documents/handlers/HTMLHandler.ts"() {
+    init_constants();
+    init_htmlToMarkdown();
+    HTMLHandler = class {
+      name = "HTMLHandler";
+      supportedFormats = ["html"];
+      async handle(buffer, filename, format, options) {
+        const html = buffer.toString("utf-8");
+        const maxLength = options.formatOptions?.html?.maxLength ?? DOCUMENT_DEFAULTS.MAX_HTML_LENGTH;
+        const result = await htmlToMarkdown(html, `file://${filename}`, maxLength);
+        const content = result.markdown;
+        const sizeBytes = Buffer.byteLength(content, "utf-8");
+        return [
+          {
+            type: "text",
+            content,
+            metadata: {
+              sourceFilename: filename,
+              format,
+              index: 0,
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN),
+              label: result.title || void 0
+            }
+          }
+        ];
+      }
+    };
   }
 });
 
-// node_modules/isexe/index.js
-var require_isexe = __commonJS({
-  "node_modules/isexe/index.js"(exports$1, module) {
-    __require("fs");
-    var core;
-    if (process.platform === "win32" || global.TESTING_WINDOWS) {
-      core = require_windows();
-    } else {
-      core = require_mode();
-    }
-    module.exports = isexe;
-    isexe.sync = sync;
-    function isexe(path6, options, cb) {
-      if (typeof options === "function") {
-        cb = options;
-        options = {};
-      }
-      if (!cb) {
-        if (typeof Promise !== "function") {
-          throw new TypeError("callback not provided");
-        }
-        return new Promise(function(resolve4, reject) {
-          isexe(path6, options || {}, function(er, is) {
-            if (er) {
-              reject(er);
-            } else {
-              resolve4(is);
-            }
-          });
+// src/capabilities/documents/handlers/OfficeHandler.ts
+async function getParseOffice() {
+  if (!parseOffice) {
+    const mod = await import('officeparser');
+    parseOffice = mod.parseOffice;
+  }
+  return parseOffice;
+}
+var parseOffice, OfficeHandler;
+var init_OfficeHandler = __esm({
+  "src/capabilities/documents/handlers/OfficeHandler.ts"() {
+    init_constants();
+    parseOffice = null;
+    OfficeHandler = class {
+      name = "OfficeHandler";
+      supportedFormats = ["docx", "pptx", "odt", "odp", "ods", "rtf"];
+      async handle(buffer, filename, format, options) {
+        const parse = await getParseOffice();
+        const extractImages = options.extractImages !== false;
+        const includeSpeakerNotes = options.formatOptions?.office?.includeSpeakerNotes !== false;
+        const ast = await parse(buffer, {
+          extractAttachments: extractImages,
+          ignoreNotes: !includeSpeakerNotes
         });
+        const pieces = [];
+        let pieceIndex = 0;
+        const content = ast.content || [];
+        const markdown = this.astToMarkdown(content, format);
+        if (format === "pptx" || format === "odp") {
+          const slides = this.splitBySlides(content);
+          for (let i = 0; i < slides.length; i++) {
+            const slideContent = this.astToMarkdown(slides[i] ?? [], format);
+            if (slideContent.trim()) {
+              const sizeBytes = Buffer.byteLength(slideContent, "utf-8");
+              pieces.push({
+                type: "text",
+                content: slideContent,
+                metadata: {
+                  sourceFilename: filename,
+                  format,
+                  index: pieceIndex++,
+                  section: `Slide ${i + 1}`,
+                  sizeBytes,
+                  estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+                }
+              });
+            }
+          }
+        } else {
+          if (markdown.trim()) {
+            const sizeBytes = Buffer.byteLength(markdown, "utf-8");
+            pieces.push({
+              type: "text",
+              content: markdown,
+              metadata: {
+                sourceFilename: filename,
+                format,
+                index: pieceIndex++,
+                sizeBytes,
+                estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+              }
+            });
+          }
+        }
+        if (extractImages && ast.attachments?.length > 0) {
+          for (const attachment of ast.attachments) {
+            if (attachment.type === "image" && attachment.data) {
+              const imageData = attachment.data;
+              const sizeBytes = Math.ceil(imageData.length * 0.75);
+              pieces.push({
+                type: "image",
+                base64: imageData,
+                mimeType: attachment.mimeType || "image/png",
+                metadata: {
+                  sourceFilename: filename,
+                  format,
+                  index: pieceIndex++,
+                  sizeBytes,
+                  estimatedTokens: DOCUMENT_DEFAULTS.IMAGE_TOKENS_AUTO,
+                  label: attachment.altText || attachment.name || void 0
+                }
+              });
+            }
+          }
+        }
+        return pieces;
       }
-      core(path6, options || {}, function(er, is) {
-        if (er) {
-          if (er.code === "EACCES" || options && options.ignoreErrors) {
-            er = null;
-            is = false;
+      /**
+       * Split AST content into slide groups
+       */
+      splitBySlides(content) {
+        const slides = [];
+        let currentSlide = [];
+        for (const node of content) {
+          if (node.type === "slide") {
+            if (currentSlide.length > 0) {
+              slides.push(currentSlide);
+            }
+            currentSlide = [node];
+          } else {
+            currentSlide.push(node);
           }
         }
-        cb(er, is);
-      });
-    }
-    function sync(path6, options) {
-      try {
-        return core.sync(path6, options || {});
-      } catch (er) {
-        if (options && options.ignoreErrors || er.code === "EACCES") {
-          return false;
-        } else {
-          throw er;
+        if (currentSlide.length > 0) {
+          slides.push(currentSlide);
+        }
+        if (slides.length === 0 && content.length > 0) {
+          slides.push(content);
         }
+        return slides;
       }
-    }
-  }
-});
-
-// node_modules/which/which.js
-var require_which = __commonJS({
-  "node_modules/which/which.js"(exports$1, module) {
-    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
-    var path6 = __require("path");
-    var COLON = isWindows ? ";" : ":";
-    var isexe = require_isexe();
-    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
-    var getPathInfo = (cmd, opt) => {
-      const colon = opt.colon || COLON;
-      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
-        // windows always checks the cwd first
-        ...isWindows ? [process.cwd()] : [],
-        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
-        "").split(colon)
-      ];
-      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
-      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
-      if (isWindows) {
-        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
-          pathExt.unshift("");
+      /**
+       * Convert AST nodes to markdown
+       */
+      astToMarkdown(nodes, format) {
+        const parts = [];
+        for (const node of nodes) {
+          const md = this.nodeToMarkdown(node, format);
+          if (md) parts.push(md);
+        }
+        return parts.join("\n\n");
       }
-      return {
-        pathEnv,
-        pathExt,
-        pathExtExe
-      };
-    };
-    var which = (cmd, opt, cb) => {
-      if (typeof opt === "function") {
-        cb = opt;
-        opt = {};
-      }
-      if (!opt)
-        opt = {};
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      const step = (i) => new Promise((resolve4, reject) => {
-        if (i === pathEnv.length)
-          return opt.all && found.length ? resolve4(found) : reject(getNotFoundError(cmd));
-        const ppRaw = pathEnv[i];
-        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path6.join(pathPart, cmd);
-        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve4(subStep(p, i, 0));
-      });
-      const subStep = (p, i, ii) => new Promise((resolve4, reject) => {
-        if (ii === pathExt.length)
-          return resolve4(step(i + 1));
-        const ext = pathExt[ii];
-        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
-          if (!er && is) {
-            if (opt.all)
-              found.push(p + ext);
-            else
-              return resolve4(p + ext);
+      /**
+       * Convert a single AST node to markdown
+       */
+      nodeToMarkdown(node, format) {
+        if (!node) return "";
+        switch (node.type) {
+          case "heading": {
+            const level = node.metadata?.level || 1;
+            const prefix = "#".repeat(Math.min(level, 6));
+            return `${prefix} ${node.text || ""}`;
+          }
+          case "paragraph":
+            return this.formatText(node);
+          case "text":
+            return this.formatText(node);
+          case "list": {
+            const items = node.children || [];
+            return items.map((item, i) => {
+              const indent = "  ".repeat(node.metadata?.indentation || 0);
+              const prefix = node.metadata?.listType === "ordered" ? `${i + 1}.` : "-";
+              return `${indent}${prefix} ${item.text || this.getNodeText(item)}`;
+            }).join("\n");
+          }
+          case "table": {
+            return this.tableToMarkdown(node);
+          }
+          case "slide": {
+            const slideNum = node.metadata?.slideNumber || "";
+            const childContent = node.children ? node.children.map((c) => this.nodeToMarkdown(c, format)).filter(Boolean).join("\n\n") : node.text || "";
+            return slideNum ? `### Slide ${slideNum}
+
+${childContent}` : childContent;
+          }
+          case "note":
+            return `> **Note:** ${node.text || this.getNodeText(node)}`;
+          case "sheet": {
+            const sheetName = node.metadata?.sheetName || "Sheet";
+            const childContent = node.children ? node.children.map((c) => this.nodeToMarkdown(c, format)).filter(Boolean).join("\n") : "";
+            return `## Sheet: ${sheetName}
+
+${childContent}`;
+          }
+          case "page": {
+            const pageNum = node.metadata?.pageNumber || "";
+            const childContent = node.children ? node.children.map((c) => this.nodeToMarkdown(c, format)).filter(Boolean).join("\n\n") : node.text || "";
+            return pageNum ? `--- Page ${pageNum} ---
+
+${childContent}` : childContent;
+          }
+          case "image":
+            return `[Image: ${node.metadata?.altText || node.metadata?.attachmentName || "embedded image"}]`;
+          case "chart":
+            return `[Chart: ${node.metadata?.attachmentName || "embedded chart"}]`;
+          default:
+            return node.text || this.getNodeText(node);
+        }
+      }
+      /**
+       * Get text from a node recursively
+       */
+      getNodeText(node) {
+        if (node.text) return node.text;
+        if (node.children) {
+          return node.children.map((c) => this.getNodeText(c)).join("");
+        }
+        return "";
+      }
+      /**
+       * Format text with markdown formatting
+       */
+      formatText(node) {
+        if (!node.children || node.children.length === 0) {
+          return node.text || "";
+        }
+        return node.children.map((child) => {
+          let text = child.text || this.getNodeText(child);
+          if (!text) return "";
+          const fmt = child.formatting;
+          if (fmt) {
+            if (fmt.bold) text = `**${text}**`;
+            if (fmt.italic) text = `_${text}_`;
+            if (fmt.strikethrough) text = `~~${text}~~`;
           }
-          return resolve4(subStep(p, i, ii + 1));
-        });
-      });
-      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
-    };
-    var whichSync = (cmd, opt) => {
-      opt = opt || {};
-      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
-      const found = [];
-      for (let i = 0; i < pathEnv.length; i++) {
-        const ppRaw = pathEnv[i];
-        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
-        const pCmd = path6.join(pathPart, cmd);
-        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        for (let j = 0; j < pathExt.length; j++) {
-          const cur = p + pathExt[j];
-          try {
-            const is = isexe.sync(cur, { pathExt: pathExtExe });
-            if (is) {
-              if (opt.all)
-                found.push(cur);
-              else
-                return cur;
-            }
-          } catch (ex) {
+          if (child.metadata?.link && child.metadata?.linkType === "external") {
+            text = `[${text}](${child.metadata.link})`;
           }
-        }
+          return text;
+        }).join("");
       }
-      if (opt.all && found.length)
-        return found;
-      if (opt.nothrow)
-        return null;
-      throw getNotFoundError(cmd);
-    };
-    module.exports = which;
-    which.sync = whichSync;
-  }
-});
+      /**
+       * Convert table node to markdown table
+       */
+      tableToMarkdown(node) {
+        if (!node.children || node.children.length === 0) return "";
+        const rows = [];
+        for (const row of node.children) {
+          if (row.type === "row" && row.children) {
+            rows.push(row.children.map((cell) => {
+              const text = cell.text || this.getNodeText(cell);
+              return text.replace(/\|/g, "\\|").trim();
+            }));
+          }
+        }
+        if (rows.length === 0) return "";
+        const maxCols = Math.max(...rows.map((r) => r.length));
+        const normalizedRows = rows.map((r) => {
+          while (r.length < maxCols) r.push("");
+          return r;
+        });
+        const firstRow = normalizedRows[0] ?? [];
+        const header = `| ${firstRow.join(" | ")} |`;
+        const separator = `| ${firstRow.map(() => "---").join(" | ")} |`;
+        const body = normalizedRows.slice(1).map((r) => `| ${r.join(" | ")} |`).join("\n");
+        return body ? `${header}
+${separator}
+${body}` : `${header}
+${separator}`;
+      }
+    };
+  }
+});
+
+// src/capabilities/documents/handlers/ExcelHandler.ts
+async function getExcelJS() {
+  if (!ExcelJS) {
+    ExcelJS = await import('exceljs');
+  }
+  return ExcelJS;
+}
+var ExcelJS, ExcelHandler;
+var init_ExcelHandler = __esm({
+  "src/capabilities/documents/handlers/ExcelHandler.ts"() {
+    init_constants();
+    ExcelJS = null;
+    ExcelHandler = class {
+      name = "ExcelHandler";
+      supportedFormats = ["xlsx", "csv"];
+      async handle(buffer, filename, format, options) {
+        const exceljs = await getExcelJS();
+        const Workbook = exceljs.Workbook || exceljs.default?.Workbook;
+        const excelOpts = {
+          maxRows: options.formatOptions?.excel?.maxRows ?? DOCUMENT_DEFAULTS.MAX_EXCEL_ROWS,
+          maxColumns: options.formatOptions?.excel?.maxColumns ?? DOCUMENT_DEFAULTS.MAX_EXCEL_COLUMNS,
+          tableFormat: options.formatOptions?.excel?.tableFormat ?? "markdown",
+          includeFormulas: options.formatOptions?.excel?.includeFormulas ?? false
+        };
+        const workbook = new Workbook();
+        if (format === "csv") {
+          await workbook.csv.read(
+            new (await import('stream')).Readable({
+              read() {
+                this.push(buffer);
+                this.push(null);
+              }
+            })
+          );
+        } else {
+          await workbook.xlsx.load(buffer);
+        }
+        const pieces = [];
+        let pieceIndex = 0;
+        const requestedSheets = options.pages;
+        workbook.eachSheet((worksheet, sheetId) => {
+          if (requestedSheets && requestedSheets.length > 0) {
+            const isRequested = requestedSheets.some((p) => {
+              if (typeof p === "number") return sheetId === p;
+              return worksheet.name === p || String(sheetId) === p;
+            });
+            if (!isRequested) return;
+          }
+          const content = this.sheetToContent(worksheet, excelOpts);
+          if (!content.trim()) return;
+          const sheetContent = format === "csv" ? content : `## Sheet: ${worksheet.name}
 
-// node_modules/path-key/index.js
-var require_path_key = __commonJS({
-  "node_modules/path-key/index.js"(exports$1, module) {
-    var pathKey = (options = {}) => {
-      const environment = options.env || process.env;
-      const platform2 = options.platform || process.platform;
-      if (platform2 !== "win32") {
-        return "PATH";
+${content}`;
+          const sizeBytes = Buffer.byteLength(sheetContent, "utf-8");
+          pieces.push({
+            type: "text",
+            content: sheetContent,
+            metadata: {
+              sourceFilename: filename,
+              format,
+              index: pieceIndex++,
+              section: format === "csv" ? void 0 : worksheet.name,
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+            }
+          });
+        });
+        return pieces;
       }
-      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
-    };
-    module.exports = pathKey;
-    module.exports.default = pathKey;
-  }
-});
-
-// node_modules/cross-spawn/lib/util/resolveCommand.js
-var require_resolveCommand = __commonJS({
-  "node_modules/cross-spawn/lib/util/resolveCommand.js"(exports$1, module) {
-    var path6 = __require("path");
-    var which = require_which();
-    var getPathKey = require_path_key();
-    function resolveCommandAttempt(parsed, withoutPathExt) {
-      const env = parsed.options.env || process.env;
-      const cwd = process.cwd();
-      const hasCustomCwd = parsed.options.cwd != null;
-      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
-      if (shouldSwitchCwd) {
-        try {
-          process.chdir(parsed.options.cwd);
-        } catch (err) {
+      /**
+       * Convert a worksheet to the configured format
+       */
+      sheetToContent(worksheet, opts) {
+        switch (opts.tableFormat) {
+          case "csv":
+            return this.sheetToCSV(worksheet, opts);
+          case "json":
+            return this.sheetToJSON(worksheet, opts);
+          default:
+            return this.sheetToMarkdownTable(worksheet, opts);
         }
       }
-      let resolved;
-      try {
-        resolved = which.sync(parsed.command, {
-          path: env[getPathKey({ env })],
-          pathExt: withoutPathExt ? path6.delimiter : void 0
+      /**
+       * Convert worksheet to markdown table
+       */
+      sheetToMarkdownTable(worksheet, opts) {
+        const rows = this.extractRows(worksheet, opts);
+        if (rows.length === 0) return "";
+        const maxCols = Math.min(
+          Math.max(...rows.map((r) => r.length)),
+          opts.maxColumns
+        );
+        const normalizedRows = rows.map((r) => {
+          const truncated = r.slice(0, maxCols);
+          while (truncated.length < maxCols) truncated.push("");
+          return truncated;
         });
-      } catch (e) {
-      } finally {
-        if (shouldSwitchCwd) {
-          process.chdir(cwd);
+        const firstRow = normalizedRows[0] ?? [];
+        const header = `| ${firstRow.join(" | ")} |`;
+        const separator = `| ${firstRow.map(() => "---").join(" | ")} |`;
+        const body = normalizedRows.slice(1).map((r) => `| ${r.join(" | ")} |`).join("\n");
+        let result = `${header}
+${separator}`;
+        if (body) result += `
+${body}`;
+        if (worksheet.rowCount > opts.maxRows) {
+          result += `
+
+_...truncated (${worksheet.rowCount - opts.maxRows} more rows)_`;
         }
+        return result;
       }
-      if (resolved) {
-        resolved = path6.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      /**
+       * Convert worksheet to CSV
+       */
+      sheetToCSV(worksheet, opts) {
+        const rows = this.extractRows(worksheet, opts);
+        return rows.map(
+          (row) => row.slice(0, opts.maxColumns).map((cell) => {
+            if (cell.includes(",") || cell.includes('"') || cell.includes("\n")) {
+              return `"${cell.replace(/"/g, '""')}"`;
+            }
+            return cell;
+          }).join(",")
+        ).join("\n");
       }
-      return resolved;
-    }
-    function resolveCommand(parsed) {
-      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
-    }
-    module.exports = resolveCommand;
-  }
-});
-
-// node_modules/cross-spawn/lib/util/escape.js
-var require_escape = __commonJS({
-  "node_modules/cross-spawn/lib/util/escape.js"(exports$1, module) {
-    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
-    function escapeCommand(arg) {
-      arg = arg.replace(metaCharsRegExp, "^$1");
-      return arg;
-    }
-    function escapeArgument(arg, doubleEscapeMetaChars) {
-      arg = `${arg}`;
-      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
-      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
-      arg = `"${arg}"`;
-      arg = arg.replace(metaCharsRegExp, "^$1");
-      if (doubleEscapeMetaChars) {
-        arg = arg.replace(metaCharsRegExp, "^$1");
+      /**
+       * Convert worksheet to JSON
+       */
+      sheetToJSON(worksheet, opts) {
+        const rows = this.extractRows(worksheet, opts);
+        if (rows.length < 2) return "[]";
+        const headers = (rows[0] ?? []).slice(0, opts.maxColumns);
+        const data = rows.slice(1).map((row) => {
+          const obj = {};
+          headers.forEach((header, i) => {
+            if (header && i < row.length) {
+              obj[header] = row[i] ?? "";
+            }
+          });
+          return obj;
+        });
+        return "```json\n" + JSON.stringify(data, null, 2) + "\n```";
       }
-      return arg;
-    }
-    module.exports.command = escapeCommand;
-    module.exports.argument = escapeArgument;
-  }
-});
-
-// node_modules/shebang-regex/index.js
-var require_shebang_regex = __commonJS({
-  "node_modules/shebang-regex/index.js"(exports$1, module) {
-    module.exports = /^#!(.*)/;
-  }
-});
-
-// node_modules/shebang-command/index.js
-var require_shebang_command = __commonJS({
-  "node_modules/shebang-command/index.js"(exports$1, module) {
-    var shebangRegex = require_shebang_regex();
-    module.exports = (string3 = "") => {
-      const match = string3.match(shebangRegex);
-      if (!match) {
-        return null;
+      /**
+       * Extract rows from worksheet as string arrays
+       */
+      extractRows(worksheet, opts) {
+        const rows = [];
+        let rowCount = 0;
+        worksheet.eachRow({ includeEmpty: false }, (row) => {
+          if (rowCount >= opts.maxRows) return;
+          rowCount++;
+          const cells = [];
+          row.eachCell({ includeEmpty: true }, (cell, colNumber) => {
+            if (colNumber > opts.maxColumns) return;
+            let value = "";
+            if (opts.includeFormulas && cell.formula) {
+              value = `${this.getCellValue(cell)} (=${cell.formula})`;
+            } else {
+              value = this.getCellValue(cell);
+            }
+            while (cells.length < colNumber - 1) cells.push("");
+            cells.push(value);
+          });
+          rows.push(cells);
+        });
+        return rows;
       }
-      const [path6, argument] = match[0].replace(/#! ?/, "").split(" ");
-      const binary = path6.split("/").pop();
-      if (binary === "env") {
-        return argument;
+      /**
+       * Get cell value as string
+       */
+      getCellValue(cell) {
+        if (cell.value === null || cell.value === void 0) return "";
+        if (typeof cell.value === "object") {
+          if (cell.value.richText) {
+            return cell.value.richText.map((rt) => rt.text || "").join("");
+          }
+          if (cell.value.hyperlink) {
+            return cell.value.text || cell.value.hyperlink;
+          }
+          if ("result" in cell.value) {
+            return String(cell.value.result ?? "");
+          }
+          if (cell.value instanceof Date) {
+            return cell.value.toISOString().split("T")[0];
+          }
+          return String(cell.value);
+        }
+        return String(cell.value).replace(/\|/g, "\\|");
       }
-      return argument ? `${binary} ${argument}` : binary;
     };
   }
 });
 
-// node_modules/cross-spawn/lib/util/readShebang.js
-var require_readShebang = __commonJS({
-  "node_modules/cross-spawn/lib/util/readShebang.js"(exports$1, module) {
-    var fs17 = __require("fs");
-    var shebangCommand = require_shebang_command();
-    function readShebang(command) {
-      const size = 150;
-      const buffer = Buffer.alloc(size);
-      let fd;
-      try {
-        fd = fs17.openSync(command, "r");
-        fs17.readSync(fd, buffer, 0, size, 0);
-        fs17.closeSync(fd);
-      } catch (e) {
-      }
-      return shebangCommand(buffer.toString());
-    }
-    module.exports = readShebang;
-  }
-});
-
-// node_modules/cross-spawn/lib/parse.js
-var require_parse = __commonJS({
-  "node_modules/cross-spawn/lib/parse.js"(exports$1, module) {
-    var path6 = __require("path");
-    var resolveCommand = require_resolveCommand();
-    var escape2 = require_escape();
-    var readShebang = require_readShebang();
-    var isWin = process.platform === "win32";
-    var isExecutableRegExp = /\.(?:com|exe)$/i;
-    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-    function detectShebang(parsed) {
-      parsed.file = resolveCommand(parsed);
-      const shebang = parsed.file && readShebang(parsed.file);
-      if (shebang) {
-        parsed.args.unshift(parsed.file);
-        parsed.command = shebang;
-        return resolveCommand(parsed);
-      }
-      return parsed.file;
-    }
-    function parseNonShell(parsed) {
-      if (!isWin) {
-        return parsed;
-      }
-      const commandFile = detectShebang(parsed);
-      const needsShell = !isExecutableRegExp.test(commandFile);
-      if (parsed.options.forceShell || needsShell) {
-        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
-        parsed.command = path6.normalize(parsed.command);
-        parsed.command = escape2.command(parsed.command);
-        parsed.args = parsed.args.map((arg) => escape2.argument(arg, needsDoubleEscapeMetaChars));
-        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
-        parsed.command = process.env.comspec || "cmd.exe";
-        parsed.options.windowsVerbatimArguments = true;
+// src/capabilities/documents/handlers/PDFHandler.ts
+async function getUnpdf() {
+  if (!unpdfModule) {
+    const mod = await import('unpdf');
+    unpdfModule = {
+      extractText: mod.extractText,
+      extractImages: mod.extractImages,
+      getMeta: mod.getMeta
+    };
+  }
+  return unpdfModule;
+}
+var unpdfModule, PDFHandler;
+var init_PDFHandler = __esm({
+  "src/capabilities/documents/handlers/PDFHandler.ts"() {
+    init_constants();
+    unpdfModule = null;
+    PDFHandler = class {
+      name = "PDFHandler";
+      supportedFormats = ["pdf"];
+      async handle(buffer, filename, format, options) {
+        const unpdf = await getUnpdf();
+        const pieces = [];
+        let pieceIndex = 0;
+        let metadata = {};
+        const includeMetadata = options.formatOptions?.pdf?.includeMetadata !== false;
+        if (includeMetadata) {
+          try {
+            metadata = await unpdf.getMeta(buffer);
+          } catch {
+          }
+        }
+        const textResult = await unpdf.extractText(buffer, { mergePages: false });
+        const pages = textResult?.pages || textResult?.text ? Array.isArray(textResult.text) ? textResult.text : [textResult.text] : [];
+        const requestedPages = options.pages;
+        const pageEntries = pages.map((text, i) => ({ text, pageNum: i + 1 }));
+        const filteredPages = requestedPages && requestedPages.length > 0 ? pageEntries.filter(
+          (p) => requestedPages.some((rp) => {
+            const num = typeof rp === "string" ? parseInt(rp, 10) : rp;
+            return num === p.pageNum;
+          })
+        ) : pageEntries;
+        if (includeMetadata && metadata?.info) {
+          const metaParts = [];
+          if (metadata.info.Title) metaParts.push(`**Title:** ${metadata.info.Title}`);
+          if (metadata.info.Author) metaParts.push(`**Author:** ${metadata.info.Author}`);
+          if (metadata.info.Subject) metaParts.push(`**Subject:** ${metadata.info.Subject}`);
+          if (metadata.info.Creator) metaParts.push(`**Creator:** ${metadata.info.Creator}`);
+          if (pages.length) metaParts.push(`**Pages:** ${pages.length}`);
+          if (metaParts.length > 0) {
+            const metaContent = metaParts.join("\n");
+            const sizeBytes = Buffer.byteLength(metaContent, "utf-8");
+            pieces.push({
+              type: "text",
+              content: metaContent,
+              metadata: {
+                sourceFilename: filename,
+                format,
+                index: pieceIndex++,
+                section: "Metadata",
+                sizeBytes,
+                estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+              }
+            });
+          }
+        }
+        for (const page of filteredPages) {
+          const text = page.text.trim();
+          if (!text) continue;
+          const sizeBytes = Buffer.byteLength(text, "utf-8");
+          pieces.push({
+            type: "text",
+            content: text,
+            metadata: {
+              sourceFilename: filename,
+              format,
+              index: pieceIndex++,
+              section: `Page ${page.pageNum}`,
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+            }
+          });
+        }
+        if (options.extractImages !== false) {
+          try {
+            const imagesResult = await unpdf.extractImages(buffer, {});
+            const images = imagesResult?.images || [];
+            for (const img of images) {
+              if (!img.data) continue;
+              const base64 = typeof img.data === "string" ? img.data : Buffer.from(img.data).toString("base64");
+              const sizeBytes = Math.ceil(base64.length * 0.75);
+              pieces.push({
+                type: "image",
+                base64,
+                mimeType: img.mimeType || "image/png",
+                width: img.width,
+                height: img.height,
+                metadata: {
+                  sourceFilename: filename,
+                  format,
+                  index: pieceIndex++,
+                  sizeBytes,
+                  estimatedTokens: DOCUMENT_DEFAULTS.IMAGE_TOKENS_AUTO,
+                  label: img.name || void 0
+                }
+              });
+            }
+          } catch {
+          }
+        }
+        return pieces;
+      }
+    };
+  }
+});
+
+// src/capabilities/documents/handlers/index.ts
+var handlers_exports = {};
+__export(handlers_exports, {
+  ExcelHandler: () => ExcelHandler,
+  HTMLHandler: () => HTMLHandler,
+  ImageHandler: () => ImageHandler,
+  OfficeHandler: () => OfficeHandler,
+  PDFHandler: () => PDFHandler,
+  TextHandler: () => TextHandler,
+  getDefaultHandlers: () => getDefaultHandlers
+});
+function getDefaultHandlers() {
+  return /* @__PURE__ */ new Map([
+    ["text", new TextHandler()],
+    ["image", new ImageHandler()],
+    ["html", new HTMLHandler()],
+    ["office", new OfficeHandler()],
+    ["spreadsheet", new ExcelHandler()],
+    ["pdf", new PDFHandler()]
+  ]);
+}
+var init_handlers = __esm({
+  "src/capabilities/documents/handlers/index.ts"() {
+    init_TextHandler();
+    init_ImageHandler();
+    init_HTMLHandler();
+    init_OfficeHandler();
+    init_ExcelHandler();
+    init_PDFHandler();
+    init_TextHandler();
+    init_ImageHandler();
+    init_HTMLHandler();
+    init_OfficeHandler();
+    init_ExcelHandler();
+    init_PDFHandler();
+  }
+});
+
+// src/capabilities/documents/transformers/DefaultTransformers.ts
+function normalizeTable(table) {
+  const lines = table.trim().split("\n");
+  if (lines.length < 2) return table;
+  const rows = lines.map(
+    (line) => line.split("|").slice(1, -1).map((cell) => cell.trim())
+  );
+  const colCount = Math.max(...rows.map((r) => r.length));
+  const colWidths = new Array(colCount).fill(3);
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const cell = row[i] ?? "";
+      if (cell.match(/^[-:]+$/)) continue;
+      colWidths[i] = Math.max(colWidths[i] ?? 3, cell.length);
+    }
+  }
+  const result = rows.map((row, rowIndex) => {
+    const cells = [];
+    for (let i = 0; i < colCount; i++) {
+      const cell = row[i] || "";
+      if (rowIndex === 1) {
+        cells.push("-".repeat(colWidths[i]));
+      } else {
+        cells.push(cell.padEnd(colWidths[i]));
       }
-      return parsed;
     }
-    function parse(command, args, options) {
-      if (args && !Array.isArray(args)) {
-        options = args;
-        args = null;
+    return `| ${cells.join(" | ")} |`;
+  });
+  return result.join("\n");
+}
+function getDefaultTransformers() {
+  return [
+    documentHeaderTransformer,
+    tableFormattingTransformer,
+    truncationTransformer
+  ];
+}
+var documentHeaderTransformer, tableFormattingTransformer, truncationTransformer;
+var init_DefaultTransformers = __esm({
+  "src/capabilities/documents/transformers/DefaultTransformers.ts"() {
+    init_constants();
+    documentHeaderTransformer = {
+      name: "documentHeaderTransformer",
+      appliesTo: [],
+      // applies to all formats
+      priority: 10,
+      async transform(pieces, context) {
+        if (pieces.length === 0) return pieces;
+        const totalSize = pieces.reduce((sum, p) => sum + p.metadata.sizeBytes, 0);
+        const sizeStr = totalSize > 1024 * 1024 ? `${(totalSize / 1024 / 1024).toFixed(1)}MB` : `${(totalSize / 1024).toFixed(1)}KB`;
+        const header = `# Document: ${context.filename}
+_Format: ${context.format.toUpperCase()} | Size: ${sizeStr}_`;
+        const headerBytes = Buffer.byteLength(header, "utf-8");
+        const headerPiece = {
+          type: "text",
+          content: header,
+          metadata: {
+            sourceFilename: context.filename,
+            format: context.format,
+            index: -1,
+            // will be re-indexed
+            section: "Header",
+            sizeBytes: headerBytes,
+            estimatedTokens: Math.ceil(headerBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+          }
+        };
+        const result = [headerPiece, ...pieces];
+        result.forEach((p, i) => {
+          p.metadata.index = i;
+        });
+        return result;
       }
-      args = args ? args.slice(0) : [];
-      options = Object.assign({}, options);
-      const parsed = {
-        command,
-        args,
-        options,
-        file: void 0,
-        original: {
-          command,
-          args
-        }
-      };
-      return options.shell ? parsed : parseNonShell(parsed);
-    }
-    module.exports = parse;
-  }
-});
-
-// node_modules/cross-spawn/lib/enoent.js
-var require_enoent = __commonJS({
-  "node_modules/cross-spawn/lib/enoent.js"(exports$1, module) {
-    var isWin = process.platform === "win32";
-    function notFoundError(original, syscall) {
-      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
-        code: "ENOENT",
-        errno: "ENOENT",
-        syscall: `${syscall} ${original.command}`,
-        path: original.command,
-        spawnargs: original.args
-      });
-    }
-    function hookChildProcess(cp, parsed) {
-      if (!isWin) {
-        return;
+    };
+    tableFormattingTransformer = {
+      name: "tableFormattingTransformer",
+      appliesTo: ["xlsx", "csv"],
+      priority: 50,
+      async transform(pieces, _context) {
+        return pieces.map((piece) => {
+          if (piece.type !== "text") return piece;
+          let content = piece.content;
+          content = content.replace(
+            /(\|[^\n]+\|\n\|[\s\-:|]+\|\n(?:\|[^\n]+\|\n?)*)/g,
+            (table) => normalizeTable(table)
+          );
+          if (content === piece.content) return piece;
+          const sizeBytes = Buffer.byteLength(content, "utf-8");
+          return {
+            ...piece,
+            content,
+            metadata: {
+              ...piece.metadata,
+              sizeBytes,
+              estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+            }
+          };
+        });
       }
-      const originalEmit = cp.emit;
-      cp.emit = function(name, arg1) {
-        if (name === "exit") {
-          const err = verifyENOENT(arg1, parsed);
-          if (err) {
-            return originalEmit.call(cp, "error", err);
+    };
+    truncationTransformer = {
+      name: "truncationTransformer",
+      appliesTo: [],
+      // applies to all formats
+      priority: 1e3,
+      // runs last
+      async transform(pieces, context) {
+        const maxTokens = context.options.maxTokens ?? DOCUMENT_DEFAULTS.MAX_OUTPUT_TOKENS;
+        const maxBytes = context.options.maxOutputBytes ?? DOCUMENT_DEFAULTS.MAX_OUTPUT_BYTES;
+        let totalTokens = 0;
+        let totalBytes = 0;
+        const result = [];
+        for (const piece of pieces) {
+          totalTokens += piece.metadata.estimatedTokens;
+          totalBytes += piece.metadata.sizeBytes;
+          if (totalTokens > maxTokens || totalBytes > maxBytes) {
+            if (piece.type === "text") {
+              const remainingTokens = maxTokens - (totalTokens - piece.metadata.estimatedTokens);
+              const remainingChars = remainingTokens * DOCUMENT_DEFAULTS.CHARS_PER_TOKEN;
+              if (remainingChars > 100) {
+                const content = piece.content;
+                const truncateAt = content.lastIndexOf("\n\n", remainingChars);
+                const cutPoint = truncateAt > remainingChars * 0.3 ? truncateAt : remainingChars;
+                const truncated = content.slice(0, cutPoint) + "\n\n..._[content truncated]_";
+                const sizeBytes = Buffer.byteLength(truncated, "utf-8");
+                result.push({
+                  ...piece,
+                  content: truncated,
+                  metadata: {
+                    ...piece.metadata,
+                    sizeBytes,
+                    estimatedTokens: Math.ceil(sizeBytes / DOCUMENT_DEFAULTS.CHARS_PER_TOKEN)
+                  }
+                });
+              }
+            }
+            break;
           }
+          result.push(piece);
         }
-        return originalEmit.apply(cp, arguments);
-      };
-    }
-    function verifyENOENT(status, parsed) {
-      if (isWin && status === 1 && !parsed.file) {
-        return notFoundError(parsed.original, "spawn");
-      }
-      return null;
-    }
-    function verifyENOENTSync(status, parsed) {
-      if (isWin && status === 1 && !parsed.file) {
-        return notFoundError(parsed.original, "spawnSync");
+        return result;
       }
-      return null;
-    }
-    module.exports = {
-      hookChildProcess,
-      verifyENOENT,
-      verifyENOENTSync,
-      notFoundError
-    };
-  }
-});
-
-// node_modules/cross-spawn/index.js
-var require_cross_spawn = __commonJS({
-  "node_modules/cross-spawn/index.js"(exports$1, module) {
-    var cp = __require("child_process");
-    var parse = require_parse();
-    var enoent = require_enoent();
-    function spawn3(command, args, options) {
-      const parsed = parse(command, args, options);
-      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
-      enoent.hookChildProcess(spawned, parsed);
-      return spawned;
-    }
-    function spawnSync(command, args, options) {
-      const parsed = parse(command, args, options);
-      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
-      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
-      return result;
-    }
-    module.exports = spawn3;
-    module.exports.spawn = spawn3;
-    module.exports.sync = spawnSync;
-    module.exports._parse = parse;
-    module.exports._enoent = enoent;
+    };
+  }
+});
+
+// src/capabilities/documents/transformers/index.ts
+var transformers_exports = {};
+__export(transformers_exports, {
+  documentHeaderTransformer: () => documentHeaderTransformer,
+  getDefaultTransformers: () => getDefaultTransformers,
+  tableFormattingTransformer: () => tableFormattingTransformer,
+  truncationTransformer: () => truncationTransformer
+});
+var init_transformers = __esm({
+  "src/capabilities/documents/transformers/index.ts"() {
+    init_DefaultTransformers();
   }
 });
 
@@ -15774,6 +16306,32 @@ var ParallelTasksError = class _ParallelTasksError extends AIError {
     return this.failures.map((f) => f.taskId);
   }
 };
+var DocumentReadError = class _DocumentReadError extends AIError {
+  constructor(source, message, originalError) {
+    super(
+      `Failed to read document '${source}': ${message}`,
+      "DOCUMENT_READ_ERROR",
+      500,
+      originalError
+    );
+    this.source = source;
+    this.name = "DocumentReadError";
+    Object.setPrototypeOf(this, _DocumentReadError.prototype);
+  }
+};
+var UnsupportedFormatError = class _UnsupportedFormatError extends AIError {
+  constructor(format, family) {
+    super(
+      `Unsupported document format: '${format}'${family ? ` (family: ${family})` : ""}`,
+      "UNSUPPORTED_FORMAT",
+      400
+    );
+    this.format = format;
+    this.family = family;
+    this.name = "UnsupportedFormatError";
+    Object.setPrototypeOf(this, _UnsupportedFormatError.prototype);
+  }
+};
 var ContextOverflowError = class _ContextOverflowError extends AIError {
   constructor(message, budget) {
     super(
@@ -18177,24 +18735,9 @@ var ContentType = /* @__PURE__ */ ((ContentType2) => {
   ContentType2["TOOL_RESULT"] = "tool_result";
   return ContentType2;
 })(ContentType || {});
-var AGENT_DEFAULTS = {
-  /** Default maximum iterations for agentic loop */
-  MAX_ITERATIONS: 50,
-  /** Default temperature for LLM calls */
-  DEFAULT_TEMPERATURE: 0.7,
-  /** Message injected when max iterations is reached */
-  MAX_ITERATIONS_MESSAGE: `You have reached the maximum iteration limit for this execution. Please:
-1. Summarize what you have accomplished so far
-2. Explain what remains to be done (if anything)
-3. Ask the user if they would like you to continue
-
-Do NOT use any tools in this response - just provide a clear summary and ask for confirmation to proceed.`
-};
-var TOKEN_ESTIMATION = {
-  /** Characters per token for mixed content */
-  MIXED_CHARS_PER_TOKEN: 3.5};
 
 // src/core/context-nextgen/BasePluginNextGen.ts
+init_constants();
 var simpleTokenEstimator = {
   estimateTokens(text) {
     if (!text || text.length === 0) return 0;
@@ -18203,6 +18746,14 @@ var simpleTokenEstimator = {
   estimateDataTokens(data) {
     const text = typeof data === "string" ? data : JSON.stringify(data);
     return this.estimateTokens(text);
+  },
+  estimateImageTokens(width, height, detail) {
+    if (detail === "low") return 85;
+    if (width && height) {
+      const tiles = Math.ceil(width / 512) * Math.ceil(height / 512);
+      return 85 + 170 * tiles;
+    }
+    return 1e3;
   }
 };
 var BasePluginNextGen = class {
@@ -21450,12 +22001,26 @@ var AgentContextNextGen = class _AgentContextNextGen extends eventemitter3.Event
       return "";
     }
     const id = this.generateId();
-    const contentArray = results.map((r) => ({
-      type: "tool_result" /* TOOL_RESULT */,
-      tool_use_id: r.tool_use_id,
-      content: typeof r.content === "string" ? r.content : JSON.stringify(r.content),
-      error: r.error
-    }));
+    const contentArray = results.map((r) => {
+      let contentStr;
+      let images;
+      if (typeof r.content === "string") {
+        contentStr = r.content;
+      } else if (r.content && Array.isArray(r.content.__images) && r.content.__images.length > 0) {
+        images = r.content.__images;
+        const { __images: _, base64: __, ...rest } = r.content;
+        contentStr = JSON.stringify(rest);
+      } else {
+        contentStr = JSON.stringify(r.content);
+      }
+      return {
+        type: "tool_result" /* TOOL_RESULT */,
+        tool_use_id: r.tool_use_id,
+        content: contentStr,
+        error: r.error,
+        ...images ? { __images: images } : {}
+      };
+    });
     const message = {
       type: "message",
       id,
@@ -21716,12 +22281,29 @@ ${content}`);
         total += this._estimator.estimateDataTokens(c.input || {});
       } else if (c.type === "tool_result" /* TOOL_RESULT */) {
         total += this._estimator.estimateTokens(c.content || "");
+        const images = c.__images;
+        if (images?.length) {
+          for (const _img of images) {
+            total += this._estimateImageTokens();
+          }
+        }
       } else if (c.type === "input_image_url" /* INPUT_IMAGE_URL */) {
-        total += 200;
+        const imgContent = c;
+        const detail = imgContent.image_url?.detail;
+        total += this._estimateImageTokens(void 0, void 0, detail);
       }
     }
     return total;
   }
+  /**
+   * Estimate tokens for a single image, using the estimator's image method if available.
+   */
+  _estimateImageTokens(width, height, detail) {
+    if (this._estimator.estimateImageTokens) {
+      return this._estimator.estimateImageTokens(width, height, detail);
+    }
+    return 1e3;
+  }
   // ============================================================================
   // Compaction
   // ============================================================================
@@ -21954,7 +22536,8 @@ ${content}`);
       if (c.type === "tool_result" /* TOOL_RESULT */) {
         const toolResult = c;
         const content = toolResult.content || "";
-        if (this.isBinaryContent(content)) {
+        const images = toolResult.__images;
+        if (!images?.length && this.isBinaryContent(content)) {
           truncatedContent.push({
             type: "tool_result" /* TOOL_RESULT */,
             tool_use_id: toolResult.tool_use_id,
@@ -21971,7 +22554,9 @@ ${content}`);
               tool_use_id: toolResult.tool_use_id,
               content: `${truncated}
 
-[TRUNCATED: Original output was ${Math.round(content.length / 1024)}KB. Only first ${Math.round(availableChars / 1024)}KB shown. Consider using more targeted queries.]`
+[TRUNCATED: Original output was ${Math.round(content.length / 1024)}KB. Only first ${Math.round(availableChars / 1024)}KB shown. Consider using more targeted queries.]`,
+              // Preserve images even when text is truncated — they're handled natively by providers
+              ...images ? { __images: images } : {}
             });
             totalCharsUsed += truncated.length + 150;
           } else if (availableChars > 0) {
@@ -21982,7 +22567,9 @@ ${content}`);
               type: "tool_result" /* TOOL_RESULT */,
               tool_use_id: toolResult.tool_use_id,
               content: "[Output too large - skipped due to context limits. Try a more targeted query.]",
-              error: "Output too large"
+              error: "Output too large",
+              // Preserve images even when text is dropped
+              ...images ? { __images: images } : {}
             });
             totalCharsUsed += 100;
           }
@@ -22511,14 +23098,41 @@ var OpenAIResponsesConverter = class {
                 arguments: content.arguments
               });
               break;
-            case "tool_result":
-              const output = typeof content.content === "string" ? content.content : JSON.stringify(content.content);
+            case "tool_result": {
+              const contentImages = content.__images;
+              let outputText;
+              let images;
+              if (contentImages?.length) {
+                outputText = typeof content.content === "string" ? content.content : JSON.stringify(content.content);
+                images = contentImages;
+              } else {
+                const rawOutput = typeof content.content === "string" ? content.content : JSON.stringify(content.content);
+                const extracted = this.extractImagesFromOutput(rawOutput);
+                outputText = extracted.text;
+                images = extracted.images;
+              }
               items.push({
                 type: "function_call_output",
                 call_id: content.tool_use_id,
-                output
+                output: outputText
               });
+              if (images.length > 0) {
+                const imageContent = images.map((img) => ({
+                  type: "input_image",
+                  image_url: `data:${img.mediaType};base64,${img.base64}`
+                }));
+                items.push({
+                  type: "message",
+                  role: "user",
+                  content: [
+                    { type: "input_text", text: "[Screenshot from tool result]" },
+                    ...imageContent
+                  ],
+                  status: "completed"
+                });
+              }
               break;
+            }
           }
         }
         if (messageContent.length > 0) {
@@ -22686,6 +23300,22 @@ var OpenAIResponsesConverter = class {
       }
     };
   }
+  /**
+   * Extract __images from a JSON tool result and return cleaned text + images.
+   * Used by the __images convention for multimodal tool results.
+   */
+  extractImagesFromOutput(output) {
+    try {
+      const parsed = JSON.parse(output);
+      if (parsed && Array.isArray(parsed.__images) && parsed.__images.length > 0) {
+        const images = parsed.__images;
+        const { __images: _, base64: __, ...rest } = parsed;
+        return { text: JSON.stringify(rest), images };
+      }
+    } catch {
+    }
+    return { text: output, images: [] };
+  }
 };
 
 // src/domain/entities/StreamEvent.ts
@@ -23491,6 +24121,7 @@ var AnthropicConverter = class extends BaseConverter {
   /**
    * Convert tool result to Anthropic block
    * Anthropic requires non-empty content when is_error is true
+   * Supports __images convention: tool results with __images get multimodal content
    */
   convertToolResultToAnthropicBlock(resultContent) {
     const isError = !!resultContent.error;
@@ -23503,6 +24134,30 @@ var AnthropicConverter = class extends BaseConverter {
     if (isError && !toolResultContent) {
       toolResultContent = resultContent.error || "Tool execution failed";
     }
+    const images = resultContent.__images?.length ? resultContent.__images : this.extractImages(toolResultContent);
+    if (images) {
+      const textContent = resultContent.__images?.length ? toolResultContent : this.stripImagesFromContent(toolResultContent);
+      const contentBlocks = [];
+      if (textContent.trim()) {
+        contentBlocks.push({ type: "text", text: textContent });
+      }
+      for (const img of images) {
+        contentBlocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: img.mediaType || "image/png",
+            data: img.base64
+          }
+        });
+      }
+      return {
+        type: "tool_result",
+        tool_use_id: resultContent.tool_use_id,
+        content: contentBlocks.length > 0 ? contentBlocks : textContent,
+        is_error: isError
+      };
+    }
     return {
       type: "tool_result",
       tool_use_id: resultContent.tool_use_id,
@@ -23510,6 +24165,32 @@ var AnthropicConverter = class extends BaseConverter {
       is_error: isError
     };
   }
+  /**
+   * Extract __images from a JSON-stringified tool result content.
+   * Returns null if no images found.
+   */
+  extractImages(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed && Array.isArray(parsed.__images) && parsed.__images.length > 0) {
+        return parsed.__images;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Strip __images and base64 fields from JSON content to reduce token usage in text.
+   */
+  stripImagesFromContent(content) {
+    try {
+      const parsed = JSON.parse(content);
+      const { __images: _, base64: __, ...rest } = parsed;
+      return JSON.stringify(rest);
+    } catch {
+      return content;
+    }
+  }
   /**
    * Convert our Tool[] -> Anthropic tools
    * Uses shared conversion utilities (DRY)
@@ -24237,18 +24918,38 @@ var GoogleConverter = class {
           }
           parts.push(functionCallPart);
           break;
-        case "tool_result" /* TOOL_RESULT */:
+        case "tool_result" /* TOOL_RESULT */: {
           const functionName = this.toolCallMapping.get(c.tool_use_id) || this.extractToolName(c.tool_use_id);
+          const contentImages = c.__images;
+          let resultText;
+          let resultImages;
+          if (contentImages?.length) {
+            resultText = typeof c.content === "string" ? c.content : JSON.stringify(c.content);
+            resultImages = contentImages;
+          } else {
+            const resultStr = typeof c.content === "string" ? c.content : JSON.stringify(c.content);
+            const extracted = this.extractImagesFromResult(resultStr);
+            resultText = extracted.text;
+            resultImages = extracted.images;
+          }
           parts.push({
             functionResponse: {
               name: functionName,
-              // Use actual function name from mapping
               response: {
-                result: typeof c.content === "string" ? c.content : c.content
+                result: resultText
               }
             }
           });
+          for (const img of resultImages) {
+            parts.push({
+              inlineData: {
+                mimeType: img.mediaType || "image/png",
+                data: img.base64
+              }
+            });
+          }
           break;
+        }
       }
     }
     return parts;
@@ -24384,6 +25085,22 @@ var GoogleConverter = class {
   reset() {
     this.clearMappings();
   }
+  /**
+   * Extract __images from a JSON tool result and return cleaned text + images.
+   * Used by the __images convention for multimodal tool results.
+   */
+  extractImagesFromResult(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed && Array.isArray(parsed.__images) && parsed.__images.length > 0) {
+        const images = parsed.__images;
+        const { __images: _, base64: __, ...rest } = parsed;
+        return { text: JSON.stringify(rest), images };
+      }
+    } catch {
+    }
+    return { text: content, images: [] };
+  }
 };
 var GoogleStreamConverter = class {
   responseId = "";
@@ -26346,6 +27063,7 @@ function assertNotDestroyed(obj, operation) {
 
 // src/core/Agent.ts
 init_Metrics();
+init_constants();
 var Agent = class _Agent extends BaseAgent {
   // ===== Agent-specific State =====
   hookManager;
@@ -27553,6 +28271,9 @@ var Agent = class _Agent extends BaseAgent {
     this._logger.debug("Agent destroyed");
   }
 };
+
+// src/core/index.ts
+init_constants();
 (class {
   static DEFAULT_PATHS = [
     "./oneringai.config.json",
@@ -30962,9 +31683,6 @@ var Client = class extends Protocol {
   }
 };
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
-var import_cross_spawn = __toESM(require_cross_spawn());
-
 // node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 var ReadBuffer = class {
   append(chunk) {
@@ -31042,7 +31760,7 @@ var StdioClientTransport = class {
       throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
     }
     return new Promise((resolve4, reject) => {
-      this._process = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
+      this._process = spawn__default.default(this._serverParams.command, this._serverParams.args ?? [], {
         // merge default env with server env because mcp server needs some env vars
         env: {
           ...getDefaultEnvironment(),
@@ -38591,6 +39309,494 @@ var ZenRowsProvider = class {
 };
 registerScrapeProvider("zenrows", ZenRowsProvider);
 
+// src/capabilities/documents/DocumentReader.ts
+init_constants();
+
+// src/capabilities/documents/FormatDetector.ts
+var EXTENSION_MAP = {
+  // Office
+  ".docx": { format: "docx", family: "office", mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
+  ".pptx": { format: "pptx", family: "office", mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
+  ".odt": { format: "odt", family: "office", mimeType: "application/vnd.oasis.opendocument.text" },
+  ".odp": { format: "odp", family: "office", mimeType: "application/vnd.oasis.opendocument.presentation" },
+  ".ods": { format: "ods", family: "office", mimeType: "application/vnd.oasis.opendocument.spreadsheet" },
+  ".rtf": { format: "rtf", family: "office", mimeType: "application/rtf" },
+  // Spreadsheet
+  ".xlsx": { format: "xlsx", family: "spreadsheet", mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
+  ".csv": { format: "csv", family: "spreadsheet", mimeType: "text/csv" },
+  // PDF
+  ".pdf": { format: "pdf", family: "pdf", mimeType: "application/pdf" },
+  // HTML
+  ".html": { format: "html", family: "html", mimeType: "text/html" },
+  ".htm": { format: "html", family: "html", mimeType: "text/html" },
+  // Text
+  ".txt": { format: "txt", family: "text", mimeType: "text/plain" },
+  ".md": { format: "md", family: "text", mimeType: "text/markdown" },
+  ".json": { format: "json", family: "text", mimeType: "application/json" },
+  ".xml": { format: "xml", family: "text", mimeType: "application/xml" },
+  ".yaml": { format: "yaml", family: "text", mimeType: "application/yaml" },
+  ".yml": { format: "yml", family: "text", mimeType: "application/yaml" },
+  // Image
+  ".png": { format: "png", family: "image", mimeType: "image/png" },
+  ".jpg": { format: "jpg", family: "image", mimeType: "image/jpeg" },
+  ".jpeg": { format: "jpeg", family: "image", mimeType: "image/jpeg" },
+  ".gif": { format: "gif", family: "image", mimeType: "image/gif" },
+  ".webp": { format: "webp", family: "image", mimeType: "image/webp" },
+  ".svg": { format: "svg", family: "image", mimeType: "image/svg+xml" }
+};
+var MIME_MAP = {
+  "application/pdf": { format: "pdf", family: "pdf" },
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": { format: "docx", family: "office" },
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": { format: "pptx", family: "office" },
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": { format: "xlsx", family: "spreadsheet" },
+  "application/vnd.oasis.opendocument.text": { format: "odt", family: "office" },
+  "application/vnd.oasis.opendocument.presentation": { format: "odp", family: "office" },
+  "application/vnd.oasis.opendocument.spreadsheet": { format: "ods", family: "office" },
+  "application/rtf": { format: "rtf", family: "office" },
+  "text/rtf": { format: "rtf", family: "office" },
+  "text/csv": { format: "csv", family: "spreadsheet" },
+  "application/csv": { format: "csv", family: "spreadsheet" }
+};
+var BINARY_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".docx",
+  ".pptx",
+  ".xlsx",
+  ".odt",
+  ".odp",
+  ".ods",
+  ".pdf",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp"
+]);
+var FormatDetector = class _FormatDetector {
+  /**
+   * Detect format from filename and optional buffer
+   */
+  static detect(filename, _buffer) {
+    const ext = _FormatDetector.getExtension(filename);
+    const entry = EXTENSION_MAP[ext];
+    if (!entry) {
+      return {
+        format: "txt",
+        family: "text",
+        mimeType: "text/plain",
+        confidence: "low"
+      };
+    }
+    return {
+      format: entry.format,
+      family: entry.family,
+      mimeType: entry.mimeType,
+      confidence: "high"
+    };
+  }
+  /**
+   * Check if an extension is a supported document format
+   * Used by readFile to detect when to use DocumentReader
+   */
+  static isDocumentFormat(ext) {
+    const normalizedExt = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+    return normalizedExt in EXTENSION_MAP;
+  }
+  /**
+   * Check if an extension is a binary document format
+   * (i.e., cannot be read as UTF-8)
+   */
+  static isBinaryDocumentFormat(ext) {
+    const normalizedExt = ext.startsWith(".") ? ext.toLowerCase() : `.${ext.toLowerCase()}`;
+    return BINARY_DOCUMENT_EXTENSIONS.has(normalizedExt);
+  }
+  /**
+   * Check if a Content-Type header indicates a document format
+   * Used by webFetch to detect downloadable documents
+   */
+  static isDocumentMimeType(contentType) {
+    const mime = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+    return mime in MIME_MAP;
+  }
+  /**
+   * Detect format from Content-Type header
+   */
+  static detectFromMimeType(contentType) {
+    const mime = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+    const entry = MIME_MAP[mime];
+    if (!entry) return null;
+    const extEntry = Object.values(EXTENSION_MAP).find(
+      (e) => e.format === entry.format
+    );
+    return {
+      format: entry.format,
+      family: entry.family,
+      mimeType: extEntry?.mimeType || mime,
+      confidence: "high"
+    };
+  }
+  /**
+   * Get all supported document extensions
+   */
+  static getSupportedExtensions() {
+    return Object.keys(EXTENSION_MAP);
+  }
+  /**
+   * Get the normalized extension from a filename
+   */
+  static getExtension(filename) {
+    const lastDot = filename.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === filename.length - 1) return "";
+    return filename.slice(lastDot).toLowerCase();
+  }
+};
+
+// src/capabilities/documents/DocumentReader.ts
+var DocumentReader = class _DocumentReader {
+  handlers;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+    this.handlers = config.handlers ? new Map(config.handlers) : /* @__PURE__ */ new Map();
+  }
+  /**
+   * Create a new DocumentReader instance
+   */
+  static create(config = {}) {
+    const reader = new _DocumentReader(config);
+    reader.registerDefaultHandlers();
+    return reader;
+  }
+  /**
+   * Register all default format handlers (lazy-loaded)
+   */
+  registerDefaultHandlers() {
+  }
+  /**
+   * Register a custom format handler
+   */
+  registerHandler(family, handler) {
+    this.handlers.set(family, handler);
+  }
+  /**
+   * Read a document from any source
+   */
+  async read(source, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const mergedOptions = {
+      ...this.config.defaults,
+      ...options,
+      formatOptions: {
+        ...this.config.defaults?.formatOptions,
+        ...options.formatOptions
+      },
+      imageFilter: {
+        ...this.config.defaults?.imageFilter,
+        ...options.imageFilter
+      }
+    };
+    try {
+      const { buffer, filename } = await this.resolveSource(
+        typeof source === "string" ? this.parseStringSource(source) : source
+      );
+      const detection = FormatDetector.detect(filename, buffer);
+      const handler = await this.getHandler(detection.family);
+      if (!handler) {
+        throw new UnsupportedFormatError(detection.format, detection.family);
+      }
+      let pieces = await handler.handle(buffer, filename, detection.format, mergedOptions);
+      if (mergedOptions.extractImages !== false) {
+        pieces = this.filterImages(pieces, mergedOptions.imageFilter);
+      } else {
+        pieces = pieces.filter((p) => p.type !== "image");
+      }
+      const transformerContext = {
+        filename,
+        format: detection.format,
+        family: detection.family,
+        options: mergedOptions
+      };
+      pieces = await this.runTransformers(pieces, transformerContext, mergedOptions);
+      const metadata = this.assembleMetadata(pieces, filename, detection, startTime);
+      return {
+        success: true,
+        pieces,
+        metadata,
+        warnings
+      };
+    } catch (error) {
+      if (error instanceof DocumentReadError || error instanceof UnsupportedFormatError) {
+        throw error;
+      }
+      throw new DocumentReadError(
+        typeof source === "string" ? source : "path" in source ? source.path : "filename" in source ? source.filename : "unknown",
+        error instanceof Error ? error.message : String(error),
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Parse a string source (auto-detect path vs URL)
+   */
+  parseStringSource(source) {
+    if (source.startsWith("http://") || source.startsWith("https://")) {
+      return { type: "url", url: source };
+    }
+    return { type: "file", path: source };
+  }
+  /**
+   * Resolve any source to a buffer and filename
+   */
+  async resolveSource(source) {
+    switch (source.type) {
+      case "file": {
+        const buffer = await fs15.readFile(source.path);
+        const filename = source.path.split("/").pop() || source.path;
+        return { buffer, filename };
+      }
+      case "url": {
+        const maxSize = this.config.maxDownloadSizeBytes ?? DOCUMENT_DEFAULTS.MAX_DOWNLOAD_SIZE_BYTES;
+        const timeout = this.config.downloadTimeoutMs ?? DOCUMENT_DEFAULTS.DOWNLOAD_TIMEOUT_MS;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+          const response = await fetch(source.url, {
+            headers: {
+              ...source.headers,
+              "User-Agent": "OneRingAI-DocumentReader/1.0"
+            },
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
+          const contentLength = response.headers.get("content-length");
+          if (contentLength && parseInt(contentLength, 10) > maxSize) {
+            throw new Error(`File too large: ${contentLength} bytes (max: ${maxSize})`);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          if (arrayBuffer.byteLength > maxSize) {
+            throw new Error(`Downloaded file too large: ${arrayBuffer.byteLength} bytes (max: ${maxSize})`);
+          }
+          const filename = this.extractFilenameFromURL(source.url, response);
+          return { buffer: Buffer.from(arrayBuffer), filename };
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error.name === "AbortError") {
+            throw new Error(`Download timed out after ${timeout}ms`);
+          }
+          throw error;
+        }
+      }
+      case "buffer": {
+        const buffer = Buffer.isBuffer(source.buffer) ? source.buffer : Buffer.from(source.buffer);
+        return { buffer, filename: source.filename };
+      }
+      case "blob": {
+        const arrayBuffer = await source.blob.arrayBuffer();
+        return { buffer: Buffer.from(arrayBuffer), filename: source.filename };
+      }
+    }
+  }
+  /**
+   * Extract filename from URL and response headers
+   */
+  extractFilenameFromURL(url2, response) {
+    const disposition = response.headers.get("content-disposition");
+    if (disposition) {
+      const match = disposition.match(/filename[^;=\n]*=(['"]?)([^'"\n;]*)\1/);
+      if (match?.[2]) return match[2];
+    }
+    try {
+      const pathname = new URL(url2).pathname;
+      const basename = pathname.split("/").pop();
+      if (basename && basename.includes(".")) return basename;
+    } catch {
+    }
+    return "document";
+  }
+  /**
+   * Get the handler for a format family, loading defaults lazily
+   */
+  async getHandler(family) {
+    if (this.handlers.has(family)) {
+      return this.handlers.get(family);
+    }
+    try {
+      const { getDefaultHandlers: getDefaultHandlers2 } = await Promise.resolve().then(() => (init_handlers(), handlers_exports));
+      const defaults = getDefaultHandlers2();
+      const handler = defaults.get(family);
+      if (handler) {
+        this.handlers.set(family, handler);
+        return handler;
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Filter images based on options
+   */
+  filterImages(pieces, filterOptions) {
+    const minWidth = filterOptions?.minWidth ?? DOCUMENT_DEFAULTS.IMAGE_FILTER.MIN_WIDTH;
+    const minHeight = filterOptions?.minHeight ?? DOCUMENT_DEFAULTS.IMAGE_FILTER.MIN_HEIGHT;
+    const minSizeBytes = filterOptions?.minSizeBytes ?? DOCUMENT_DEFAULTS.IMAGE_FILTER.MIN_SIZE_BYTES;
+    const maxImages = filterOptions?.maxImages ?? DOCUMENT_DEFAULTS.MAX_EXTRACTED_IMAGES;
+    const excludePatterns = filterOptions?.excludePatterns ?? [];
+    let imageCount = 0;
+    return pieces.filter((piece) => {
+      if (piece.type !== "image") return true;
+      const img = piece;
+      if (img.width !== void 0 && img.width < minWidth) return false;
+      if (img.height !== void 0 && img.height < minHeight) return false;
+      if (img.metadata.sizeBytes < minSizeBytes) return false;
+      const label = img.metadata.label || "";
+      if (excludePatterns.some((p) => p.test(label))) return false;
+      imageCount++;
+      if (imageCount > maxImages) return false;
+      return true;
+    });
+  }
+  /**
+   * Run the transformer pipeline
+   */
+  async runTransformers(pieces, context, options) {
+    const transformers = [];
+    if (!options.skipDefaultTransformers) {
+      try {
+        const { getDefaultTransformers: getDefaultTransformers2 } = await Promise.resolve().then(() => (init_transformers(), transformers_exports));
+        transformers.push(...getDefaultTransformers2());
+      } catch {
+      }
+    }
+    if (options.transformers) {
+      transformers.push(...options.transformers);
+    }
+    transformers.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+    let result = pieces;
+    for (const transformer of transformers) {
+      if (transformer.appliesTo.length === 0 || transformer.appliesTo.includes(context.format)) {
+        result = await transformer.transform(result, context);
+      }
+    }
+    return result;
+  }
+  /**
+   * Assemble metadata from pieces
+   */
+  assembleMetadata(pieces, filename, detection, startTime) {
+    const textPieces = pieces.filter((p) => p.type === "text");
+    const imagePieces = pieces.filter((p) => p.type === "image");
+    const totalSizeBytes = pieces.reduce((sum, p) => sum + p.metadata.sizeBytes, 0);
+    const estimatedTokens = pieces.reduce((sum, p) => sum + p.metadata.estimatedTokens, 0);
+    return {
+      filename,
+      format: detection.format,
+      family: detection.family,
+      mimeType: detection.mimeType,
+      totalPieces: pieces.length,
+      totalTextPieces: textPieces.length,
+      totalImagePieces: imagePieces.length,
+      totalSizeBytes,
+      estimatedTokens,
+      processingTimeMs: Date.now() - startTime
+    };
+  }
+};
+function mergeTextPieces(pieces) {
+  return pieces.filter((p) => p.type === "text").map((p) => p.content).join("\n\n");
+}
+
+// src/capabilities/documents/index.ts
+init_handlers();
+init_transformers();
+
+// src/utils/documentContentBridge.ts
+function documentToContent(result, options = {}) {
+  const {
+    imageDetail = "auto",
+    imageFilter,
+    maxImages = 20,
+    mergeAdjacentText = true
+  } = options;
+  const minWidth = imageFilter?.minWidth ?? 0;
+  const minHeight = imageFilter?.minHeight ?? 0;
+  const minSizeBytes = imageFilter?.minSizeBytes ?? 0;
+  const excludePatterns = imageFilter?.excludePatterns ?? [];
+  const contents = [];
+  let imageCount = 0;
+  let pendingText = [];
+  const flushText = () => {
+    if (pendingText.length > 0) {
+      const text = {
+        type: "input_text" /* INPUT_TEXT */,
+        text: pendingText.join("\n\n")
+      };
+      contents.push(text);
+      pendingText = [];
+    }
+  };
+  for (const piece of result.pieces) {
+    if (piece.type === "text") {
+      if (mergeAdjacentText) {
+        pendingText.push(piece.content);
+      } else {
+        const text = {
+          type: "input_text" /* INPUT_TEXT */,
+          text: piece.content
+        };
+        contents.push(text);
+      }
+    } else if (piece.type === "image") {
+      if (piece.width !== void 0 && piece.width < minWidth) continue;
+      if (piece.height !== void 0 && piece.height < minHeight) continue;
+      if (piece.metadata.sizeBytes < minSizeBytes) continue;
+      const label = piece.metadata.label || "";
+      if (excludePatterns.some((p) => p.test(label))) continue;
+      imageCount++;
+      if (imageCount > maxImages) continue;
+      flushText();
+      const imageContent = {
+        type: "input_image_url" /* INPUT_IMAGE_URL */,
+        image_url: {
+          url: `data:${piece.mimeType};base64,${piece.base64}`,
+          detail: imageDetail
+        }
+      };
+      contents.push(imageContent);
+    }
+  }
+  flushText();
+  return contents;
+}
+async function readDocumentAsContent(source, options = {}) {
+  const {
+    imageDetail,
+    maxImages,
+    mergeAdjacentText,
+    // imageFilter is shared between both
+    ...readOptions
+  } = options;
+  const contentOptions = {
+    imageDetail,
+    imageFilter: options.imageFilter,
+    maxImages,
+    mergeAdjacentText
+  };
+  const reader = DocumentReader.create();
+  const result = await reader.read(source, readOptions);
+  if (!result.success) {
+    return [
+      {
+        type: "input_text" /* INPUT_TEXT */,
+        text: `[Document read error: ${result.error || "Unknown error"}]`
+      }
+    ];
+  }
+  return documentToContent(result, contentOptions);
+}
+
 // src/domain/interfaces/IContextStorage.ts
 var CONTEXT_SESSION_FORMAT_VERSION = 1;
 
@@ -40531,6 +41737,21 @@ var ApproximateTokenEstimator = class {
       return 100;
     }
   }
+  /**
+   * Estimate tokens for an image using tile-based model (matches OpenAI pricing).
+   *
+   * - detail='low': 85 tokens
+   * - detail='high' with known dimensions: 85 + 170 per 512×512 tile
+   * - Unknown dimensions: 1000 tokens (conservative default)
+   */
+  estimateImageTokens(width, height, detail) {
+    if (detail === "low") return 85;
+    if (width && height) {
+      const tiles = Math.ceil(width / 512) * Math.ceil(height / 512);
+      return 85 + 170 * tiles;
+    }
+    return 1e3;
+  }
 };
 
 // src/infrastructure/context/estimators/index.ts
@@ -40758,10 +41979,17 @@ var FileContextStorage = class {
   }
   /**
    * Get the storage path (for display/debugging)
+   * @deprecated Use getLocation() instead
    */
   getPath() {
     return this.sessionsDirectory;
   }
+  /**
+   * Get a human-readable storage location string (for display/debugging)
+   */
+  getLocation() {
+    return this.sessionsDirectory;
+  }
   /**
    * Get the agent ID
    */
@@ -41133,7 +42361,7 @@ var FileAgentDefinitionStorage = class {
 function createFileAgentDefinitionStorage(config) {
   return new FileAgentDefinitionStorage(config);
 }
-var MIME_TYPES = {
+var MIME_TYPES2 = {
   png: "image/png",
   jpeg: "image/jpeg",
   jpg: "image/jpeg",
@@ -41163,7 +42391,7 @@ var FileMediaStorage = class {
     const filePath = path2__namespace.join(dir, filename);
     await fs15__namespace.writeFile(filePath, data);
     const format = metadata.format.toLowerCase();
-    const mimeType = MIME_TYPES[format] ?? "application/octet-stream";
+    const mimeType = MIME_TYPES2[format] ?? "application/octet-stream";
     return {
       location: filePath,
       mimeType,
@@ -41208,7 +42436,7 @@ var FileMediaStorage = class {
         const stat6 = await fs15__namespace.stat(filePath);
         if (!stat6.isFile()) continue;
         const ext = path2__namespace.extname(file).slice(1).toLowerCase();
-        const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+        const mimeType = MIME_TYPES2[ext] ?? "application/octet-stream";
         let type;
         for (const prefix of MEDIA_TYPE_PREFIXES) {
           if (file.startsWith(`${prefix}_`)) {
@@ -45485,13 +46713,30 @@ function extractNumber(text, patterns = [
 var tools_exports = {};
 __export(tools_exports, {
   ConnectorTools: () => ConnectorTools,
+  DEFAULT_DESKTOP_CONFIG: () => DEFAULT_DESKTOP_CONFIG,
   DEFAULT_FILESYSTEM_CONFIG: () => DEFAULT_FILESYSTEM_CONFIG,
   DEFAULT_SHELL_CONFIG: () => DEFAULT_SHELL_CONFIG,
+  DESKTOP_TOOL_NAMES: () => DESKTOP_TOOL_NAMES,
+  DocumentReader: () => DocumentReader,
   FileMediaOutputHandler: () => FileMediaStorage,
+  FormatDetector: () => FormatDetector,
+  NutTreeDriver: () => NutTreeDriver,
   ToolRegistry: () => ToolRegistry,
+  applyHumanDelay: () => applyHumanDelay,
   bash: () => bash,
   createBashTool: () => createBashTool,
   createCreatePRTool: () => createCreatePRTool,
+  createDesktopGetCursorTool: () => createDesktopGetCursorTool,
+  createDesktopGetScreenSizeTool: () => createDesktopGetScreenSizeTool,
+  createDesktopKeyboardKeyTool: () => createDesktopKeyboardKeyTool,
+  createDesktopKeyboardTypeTool: () => createDesktopKeyboardTypeTool,
+  createDesktopMouseClickTool: () => createDesktopMouseClickTool,
+  createDesktopMouseDragTool: () => createDesktopMouseDragTool,
+  createDesktopMouseMoveTool: () => createDesktopMouseMoveTool,
+  createDesktopMouseScrollTool: () => createDesktopMouseScrollTool,
+  createDesktopScreenshotTool: () => createDesktopScreenshotTool,
+  createDesktopWindowFocusTool: () => createDesktopWindowFocusTool,
+  createDesktopWindowListTool: () => createDesktopWindowListTool,
   createEditFileTool: () => createEditFileTool,
   createExecuteJavaScriptTool: () => createExecuteJavaScriptTool,
   createGetPRTool: () => createGetPRTool,
@@ -45511,12 +46756,25 @@ __export(tools_exports, {
   createWebScrapeTool: () => createWebScrapeTool,
   createWebSearchTool: () => createWebSearchTool,
   createWriteFileTool: () => createWriteFileTool,
+  desktopGetCursor: () => desktopGetCursor,
+  desktopGetScreenSize: () => desktopGetScreenSize,
+  desktopKeyboardKey: () => desktopKeyboardKey,
+  desktopKeyboardType: () => desktopKeyboardType,
+  desktopMouseClick: () => desktopMouseClick,
+  desktopMouseDrag: () => desktopMouseDrag,
+  desktopMouseMove: () => desktopMouseMove,
+  desktopMouseScroll: () => desktopMouseScroll,
+  desktopScreenshot: () => desktopScreenshot,
+  desktopTools: () => desktopTools,
+  desktopWindowFocus: () => desktopWindowFocus,
+  desktopWindowList: () => desktopWindowList,
   developerTools: () => developerTools,
   editFile: () => editFile,
   executeJavaScript: () => executeJavaScript,
   expandTilde: () => expandTilde,
   getAllBuiltInTools: () => getAllBuiltInTools,
   getBackgroundOutput: () => getBackgroundOutput,
+  getDesktopDriver: () => getDesktopDriver,
   getMediaOutputHandler: () => getMediaOutputHandler,
   getMediaStorage: () => getMediaStorage,
   getToolByName: () => getToolByName,
@@ -45531,8 +46789,11 @@ __export(tools_exports, {
   jsonManipulator: () => jsonManipulator,
   killBackgroundProcess: () => killBackgroundProcess,
   listDirectory: () => listDirectory,
+  mergeTextPieces: () => mergeTextPieces,
+  parseKeyCombo: () => parseKeyCombo,
   parseRepository: () => parseRepository,
   readFile: () => readFile5,
+  resetDefaultDriver: () => resetDefaultDriver,
   resolveRepository: () => resolveRepository,
   setMediaOutputHandler: () => setMediaOutputHandler,
   setMediaStorage: () => setMediaStorage,
@@ -45578,13 +46839,11 @@ var DEFAULT_FILESYSTEM_CONFIG = {
     ".avi",
     ".mov",
     ".mkv",
-    ".pdf",
+    // Note: .pdf, .docx, .xlsx, .pptx are NOT excluded — DocumentReader handles them
     ".doc",
-    ".docx",
     ".xls",
-    ".xlsx",
     ".ppt",
-    ".pptx",
+    // Legacy Office formats not yet supported
     ".woff",
     ".woff2",
     ".ttf",
@@ -45592,6 +46851,9 @@ var DEFAULT_FILESYSTEM_CONFIG = {
     ".otf"
   ]
 };
+function toForwardSlash(p) {
+  return path2.sep === "\\" ? p.replace(/\\/g, "/") : p;
+}
 function validatePath(inputPath, config = {}) {
   const workingDir = config.workingDirectory || process.cwd();
   const allowedDirs = config.allowedDirectories || [];
@@ -45608,7 +46870,8 @@ function validatePath(inputPath, config = {}) {
   } else {
     resolvedPath = path2.resolve(workingDir, expandedPath);
   }
-  const pathSegments = resolvedPath.split("/").filter(Boolean);
+  const normalizedResolved = toForwardSlash(resolvedPath);
+  const pathSegments = normalizedResolved.split("/").filter(Boolean);
   for (const blocked of blockedDirs) {
     if (!blocked.includes("/")) {
       if (pathSegments.includes(blocked)) {
@@ -45619,8 +46882,8 @@ function validatePath(inputPath, config = {}) {
         };
       }
     } else {
-      const blockedPath = path2.isAbsolute(blocked) ? blocked : path2.resolve(workingDir, blocked);
-      if (resolvedPath.startsWith(blockedPath + "/") || resolvedPath === blockedPath) {
+      const blockedPath = toForwardSlash(path2.isAbsolute(blocked) ? blocked : path2.resolve(workingDir, blocked));
+      if (normalizedResolved.startsWith(blockedPath + "/") || normalizedResolved === blockedPath) {
         return {
           valid: false,
           resolvedPath,
@@ -45632,8 +46895,8 @@ function validatePath(inputPath, config = {}) {
   if (allowedDirs.length > 0) {
     let isAllowed = false;
     for (const allowed of allowedDirs) {
-      const allowedPath = path2.isAbsolute(allowed) ? allowed : path2.resolve(workingDir, allowed);
-      if (resolvedPath.startsWith(allowedPath + "/") || resolvedPath === allowedPath) {
+      const allowedPath = toForwardSlash(path2.isAbsolute(allowed) ? allowed : path2.resolve(workingDir, allowed));
+      if (normalizedResolved.startsWith(allowedPath + "/") || normalizedResolved === allowedPath) {
         isAllowed = true;
         break;
       }
@@ -45667,7 +46930,7 @@ function createReadFileTool(config = {}) {
       type: "function",
       function: {
         name: "read_file",
-        description: `Read content from a file on the local filesystem.
+        description: `Read content from a file on the local filesystem. Supports text files AND binary document formats \u2014 PDF, DOCX, PPTX, XLSX, ODS, ODT, ODP, and images (PNG, JPG, GIF, WEBP) are automatically converted to markdown text.
 
 USAGE:
 - The file_path parameter must be an absolute path, not a relative path
@@ -45676,20 +46939,34 @@ USAGE:
 - Any lines longer than 2000 characters will be truncated
 - Results are returned with line numbers starting at 1
 
+DOCUMENT SUPPORT:
+- PDF files: extracted as markdown text with per-page sections
+- Word documents (.docx): converted to markdown preserving headings, lists, tables
+- PowerPoint (.pptx): extracted slide-by-slide as markdown
+- Excel (.xlsx) / CSV / ODS: tables converted to markdown tables
+- OpenDocument (.odt, .odp, .ods): converted like their MS Office equivalents
+- Images (.png, .jpg, .gif, .webp): described as image metadata
+- Binary documents are auto-detected by extension \u2014 just pass the file path
+
 WHEN TO USE:
 - To read source code files before making edits
 - To understand file contents and structure
 - To read configuration files
 - To examine log files or data files
+- To read PDF, Word, Excel, PowerPoint, or other document files as text
 
 IMPORTANT:
 - Always read a file before attempting to edit it
 - Use offset/limit for very large files to read in chunks
 - The tool will return an error if the file doesn't exist
+- offset/limit are ignored for binary document formats (full document is always returned)
 
 EXAMPLES:
 - Read entire file: { "file_path": "/path/to/file.ts" }
-- Read lines 100-200: { "file_path": "/path/to/file.ts", "offset": 100, "limit": 100 }`,
+- Read lines 100-200: { "file_path": "/path/to/file.ts", "offset": 100, "limit": 100 }
+- Read a PDF: { "file_path": "/path/to/report.pdf" }
+- Read an Excel file: { "file_path": "/path/to/data.xlsx" }
+- Read a Word doc: { "file_path": "/path/to/document.docx" }`,
         parameters: {
           type: "object",
           properties: {
@@ -45751,6 +47028,32 @@ EXAMPLES:
             size: stats.size
           };
         }
+        const ext = path2.extname(resolvedPath).toLowerCase();
+        if (FormatDetector.isBinaryDocumentFormat(ext)) {
+          try {
+            const reader = DocumentReader.create(mergedConfig.documentReaderConfig);
+            const result2 = await reader.read(
+              { type: "file", path: resolvedPath },
+              {
+                extractImages: false,
+                ...mergedConfig.documentReaderConfig?.defaults
+              }
+            );
+            if (result2.success) {
+              const content2 = mergeTextPieces(result2.pieces);
+              return {
+                success: true,
+                content: content2,
+                lines: content2.split("\n").length,
+                truncated: false,
+                encoding: "document",
+                size: stats.size,
+                path: file_path
+              };
+            }
+          } catch {
+          }
+        }
         const content = await fs15.readFile(resolvedPath, "utf-8");
         const allLines = content.split("\n");
         const totalLines = allLines.length;
@@ -46072,7 +47375,7 @@ async function findFiles(dir, pattern, baseDir, config, results = [], depth = 0)
     for (const entry of entries) {
       if (results.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
-      const relativePath = path2.relative(baseDir, fullPath);
+      const relativePath = toForwardSlash(path2.relative(baseDir, fullPath));
       if (entry.isDirectory()) {
         const isBlocked = config.blockedDirectories.some(
           (blocked) => entry.name === blocked || relativePath.includes(`/${blocked}/`) || relativePath.startsWith(`${blocked}/`)
@@ -46435,7 +47738,7 @@ WHEN TO USE:
           );
           if (matches.length > 0) {
             filesMatched++;
-            const relativePath = path2.relative(resolvedPath, file) || file;
+            const relativePath = toForwardSlash(path2.relative(resolvedPath, file)) || file;
             for (const match of matches) {
               match.file = relativePath;
             }
@@ -46501,7 +47804,7 @@ async function listDir(dir, baseDir, config, recursive, filter, maxDepth = 3, cu
     for (const entry of dirEntries) {
       if (entries.length >= config.maxResults) break;
       const fullPath = path2.join(dir, entry.name);
-      const relativePath = path2.relative(baseDir, fullPath);
+      const relativePath = toForwardSlash(path2.relative(baseDir, fullPath));
       if (entry.isDirectory() && config.blockedDirectories.includes(entry.name)) {
         continue;
       }
@@ -46716,6 +48019,8 @@ function createBashTool(config = {}) {
         name: "bash",
         description: `Execute shell commands with optional timeout.
 
+SHELL: This tool uses ${mergedConfig.shell}${process.platform === "win32" ? " (Windows). Use Windows command syntax (dir, type, del, etc.), NOT Unix commands (ls, cat, rm, etc.). Use \\ as path separator or quote paths with forward slashes." : " (Unix). Use standard Unix command syntax."}
+
 USAGE:
 - Execute any shell command
 - Working directory persists between commands
@@ -46732,9 +48037,11 @@ For file operations, prefer dedicated tools:
 
 BEST PRACTICES:
 - Always quote file paths with spaces: cd "/path with spaces"
-- Use absolute paths when possible
+- Use absolute paths when possible${process.platform === "win32" ? `
+- Chain dependent commands with &&: git add . && git commit -m "msg"
+- Use PowerShell syntax if cmd.exe is insufficient` : `
 - Chain dependent commands with &&: git add . && git commit -m "msg"
-- Use ; only when you don't care if earlier commands fail
+- Use ; only when you don't care if earlier commands fail`}
 - Avoid interactive commands (no -i flags)
 
 GIT SAFETY:
@@ -47451,92 +48758,30 @@ function detectContentQuality(html, text, $) {
     issues
   };
 }
-var JSDOM = null;
-async function getJSDOM() {
-  if (!JSDOM) {
-    const jsdom = await import('jsdom');
-    JSDOM = jsdom.JSDOM;
-  }
-  return JSDOM;
-}
-async function htmlToMarkdown(html, url2, maxLength = 5e4) {
-  const JSDOMClass = await getJSDOM();
-  const dom = new JSDOMClass(html, { url: url2 });
-  const document = dom.window.document;
-  let title = document.title || "";
-  let byline;
-  let excerpt;
-  let contentHtml = html;
-  let wasReadabilityUsed = false;
-  try {
-    const clonedDoc = document.cloneNode(true);
-    const reader = new readability.Readability(clonedDoc);
-    const article = reader.parse();
-    if (article && article.content && article.content.length > 100) {
-      contentHtml = article.content;
-      title = article.title || title;
-      byline = article.byline || void 0;
-      excerpt = article.excerpt || void 0;
-      wasReadabilityUsed = true;
-    }
-  } catch {
-  }
-  const turndown = new TurndownService__default.default({
-    headingStyle: "atx",
-    codeBlockStyle: "fenced",
-    bulletListMarker: "-",
-    emDelimiter: "_"
-  });
-  turndown.remove(["script", "style", "nav", "footer", "aside", "iframe", "noscript"]);
-  turndown.addRule("pre", {
-    filter: ["pre"],
-    replacement: (content, node) => {
-      const element = node;
-      const code = element.querySelector?.("code");
-      const lang = code?.className?.match(/language-(\w+)/)?.[1] || "";
-      const text = code?.textContent || content;
-      return `
-\`\`\`${lang}
-${text}
-\`\`\`
-`;
-    }
-  });
-  let markdown = turndown.turndown(contentHtml);
-  markdown = markdown.replace(/\n{3,}/g, "\n\n").replace(/^\s+|\s+$/g, "").replace(/[ \t]+$/gm, "");
-  let wasTruncated = false;
-  if (markdown.length > maxLength) {
-    const truncateAt = markdown.lastIndexOf("\n\n", maxLength);
-    if (truncateAt > maxLength * 0.5) {
-      markdown = markdown.slice(0, truncateAt) + "\n\n...[content truncated]";
-    } else {
-      markdown = markdown.slice(0, maxLength) + "...[truncated]";
-    }
-    wasTruncated = true;
-  }
-  return {
-    markdown,
-    title,
-    byline,
-    excerpt,
-    wasReadabilityUsed,
-    wasTruncated
-  };
-}
 
 // src/tools/web/webFetch.ts
+init_htmlToMarkdown();
 var webFetch = {
   definition: {
     type: "function",
     function: {
       name: "web_fetch",
-      description: `Fetch and extract text content from a web page URL.
+      description: `Fetch and extract content from a URL \u2014 works with web pages AND document files (PDF, DOCX, XLSX, PPTX, etc.). Document URLs are automatically detected and converted to markdown text.
 
-IMPORTANT: This tool performs a simple HTTP fetch and HTML parsing. It works well for:
+WEB PAGES:
+This tool performs HTTP fetch and HTML parsing. It works well for:
 - Static websites (blogs, documentation, articles)
 - Server-rendered HTML pages
 - Content that doesn't require JavaScript
 
+DOCUMENT URLs:
+When the URL points to a document file (detected via Content-Type header or URL extension), the document is automatically downloaded and converted to markdown:
+- PDF files: extracted as markdown with per-page sections
+- Word (.docx), PowerPoint (.pptx): converted to structured markdown
+- Excel (.xlsx), CSV, ODS: tables converted to markdown tables
+- OpenDocument formats (.odt, .odp, .ods): converted like MS Office equivalents
+- Returns contentType: "document" and includes documentMetadata in the result
+
 LIMITATIONS:
 - Cannot execute JavaScript
 - May fail on React/Vue/Angular sites (will return low quality score)
@@ -47556,8 +48801,8 @@ RETURNS:
   success: boolean,
   url: string,
   title: string,
-  content: string,          // Clean markdown (converted from HTML via Readability + Turndown)
-  contentType: string,      // 'html' | 'json' | 'text' | 'error'
+  content: string,          // Clean markdown (converted from HTML or document)
+  contentType: string,      // 'html' | 'json' | 'text' | 'document' | 'error'
   qualityScore: number,     // 0-100 (quality of extraction)
   requiresJS: boolean,      // True if site likely needs JavaScript
   suggestedAction: string,  // Suggestion if quality is low
@@ -47565,20 +48810,24 @@ RETURNS:
   excerpt: string,          // Short summary excerpt (if extracted)
   byline: string,           // Author info (if extracted)
   wasTruncated: boolean,    // True if content was truncated
+  documentMetadata: object, // Document metadata (format, pages, etc.) \u2014 only for document URLs
   error: string             // Error message if failed
 }
 
-EXAMPLE:
-To fetch a blog post:
+EXAMPLES:
+Fetch a blog post:
 {
   url: "https://example.com/blog/article"
 }
 
-With custom user agent:
+Fetch a PDF document:
+{
+  url: "https://example.com/reports/q4-2025.pdf"
+}
+
+Fetch an Excel spreadsheet:
 {
-  url: "https://example.com/page",
-  userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64)...",
-  timeout: 15000
+  url: "https://example.com/data/metrics.xlsx"
 }`,
       parameters: {
         type: "object",
@@ -47642,6 +48891,51 @@ With custom user agent:
         };
       }
       const contentType = response.headers.get("content-type") || "";
+      const urlExt = (() => {
+        try {
+          const pathname = new URL(args.url).pathname;
+          const ext = pathname.split(".").pop()?.toLowerCase();
+          return ext ? `.${ext}` : "";
+        } catch {
+          return "";
+        }
+      })();
+      if (FormatDetector.isDocumentMimeType(contentType) || FormatDetector.isBinaryDocumentFormat(urlExt)) {
+        try {
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          const disposition = response.headers.get("content-disposition");
+          let filename = "document";
+          if (disposition) {
+            const match = disposition.match(/filename[^;=\n]*=(['"]?)([^'"\n;]*)\1/);
+            if (match?.[2]) filename = match[2];
+          } else {
+            try {
+              const basename = new URL(args.url).pathname.split("/").pop();
+              if (basename && basename.includes(".")) filename = basename;
+            } catch {
+            }
+          }
+          const reader = DocumentReader.create();
+          const result = await reader.read(
+            { type: "buffer", buffer, filename },
+            { extractImages: false }
+          );
+          if (result.success) {
+            return {
+              success: true,
+              url: args.url,
+              title: `Document: ${filename}`,
+              content: mergeTextPieces(result.pieces),
+              contentType: "document",
+              qualityScore: 100,
+              requiresJS: false,
+              documentMetadata: result.metadata
+            };
+          }
+        } catch {
+        }
+      }
       if (contentType.includes("application/json")) {
         const json = await response.json();
         return {
@@ -47908,6 +49202,10 @@ For JS-heavy sites:
       const api = await tryAPI(args, startTime, attemptedMethods);
       if (api.success) return api;
       if (native.success) return native;
+      const errors = [];
+      if (native.error) errors.push(`native: ${native.error}`);
+      if (api.error) errors.push(`api(${connector.name}): ${api.error}`);
+      const detail = errors.length > 0 ? errors.join(" | ") : "Unknown failure";
       return {
         success: false,
         url: args.url,
@@ -47916,7 +49214,7 @@ For JS-heavy sites:
         content: "",
         durationMs: Date.now() - startTime,
         attemptedMethods,
-        error: "All scraping methods failed. Site may have bot protection."
+        error: `All scraping methods failed. ${detail}`
       };
     },
     describeCall: (args) => args.url
@@ -49580,6 +50878,819 @@ function registerGitHubTools() {
 // src/tools/github/index.ts
 registerGitHubTools();
 
+// src/tools/desktop/types.ts
+var DEFAULT_DESKTOP_CONFIG = {
+  driver: null,
+  // Lazy-initialized
+  humanDelay: [50, 150],
+  humanizeMovement: false
+};
+async function applyHumanDelay(config) {
+  const [min, max] = config.humanDelay ?? DEFAULT_DESKTOP_CONFIG.humanDelay;
+  if (min === 0 && max === 0) return;
+  const delay = min + Math.random() * (max - min);
+  await new Promise((resolve4) => setTimeout(resolve4, delay));
+}
+var DESKTOP_TOOL_NAMES = [
+  "desktop_screenshot",
+  "desktop_mouse_move",
+  "desktop_mouse_click",
+  "desktop_mouse_drag",
+  "desktop_mouse_scroll",
+  "desktop_get_cursor",
+  "desktop_keyboard_type",
+  "desktop_keyboard_key",
+  "desktop_get_screen_size",
+  "desktop_window_list",
+  "desktop_window_focus"
+];
+
+// src/tools/desktop/driver/NutTreeDriver.ts
+var KEY_MAP = {
+  // Modifiers
+  ctrl: "LeftControl",
+  control: "LeftControl",
+  cmd: "LeftCmd",
+  command: "LeftCmd",
+  meta: "LeftCmd",
+  super: "LeftCmd",
+  alt: "LeftAlt",
+  option: "LeftAlt",
+  shift: "LeftShift",
+  // Navigation
+  enter: "Return",
+  return: "Return",
+  tab: "Tab",
+  escape: "Escape",
+  esc: "Escape",
+  backspace: "Backspace",
+  delete: "Delete",
+  space: "Space",
+  // Arrow keys
+  up: "Up",
+  down: "Down",
+  left: "Left",
+  right: "Right",
+  // Function keys
+  f1: "F1",
+  f2: "F2",
+  f3: "F3",
+  f4: "F4",
+  f5: "F5",
+  f6: "F6",
+  f7: "F7",
+  f8: "F8",
+  f9: "F9",
+  f10: "F10",
+  f11: "F11",
+  f12: "F12",
+  // Other
+  home: "Home",
+  end: "End",
+  pageup: "PageUp",
+  pagedown: "PageDown",
+  insert: "Insert",
+  printscreen: "Print",
+  capslock: "CapsLock",
+  numlock: "NumLock",
+  scrolllock: "ScrollLock"
+};
+function parseKeyCombo(keys, KeyEnum) {
+  const parts = keys.toLowerCase().split("+").map((k) => k.trim());
+  const result = [];
+  for (const part of parts) {
+    const mapped = KEY_MAP[part];
+    if (mapped && KeyEnum[mapped] !== void 0) {
+      result.push(KeyEnum[mapped]);
+      continue;
+    }
+    if (part.length === 1) {
+      const upper = part.toUpperCase();
+      if (KeyEnum[upper] !== void 0) {
+        result.push(KeyEnum[upper]);
+        continue;
+      }
+    }
+    const pascal = part.charAt(0).toUpperCase() + part.slice(1);
+    if (KeyEnum[pascal] !== void 0) {
+      result.push(KeyEnum[pascal]);
+      continue;
+    }
+    if (KeyEnum[part] !== void 0) {
+      result.push(KeyEnum[part]);
+      continue;
+    }
+    throw new Error(`Unknown key: "${part}". Available modifiers: ctrl, cmd, alt, shift. Common keys: enter, tab, escape, space, up, down, left, right, f1-f12, a-z, 0-9`);
+  }
+  return result;
+}
+async function encodeRGBAToPNG(data, width, height) {
+  const { PNG } = await import('pngjs');
+  const png = new PNG({ width, height });
+  const sourceBuffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+  sourceBuffer.copy(png.data, 0, 0, width * height * 4);
+  return PNG.sync.write(png);
+}
+var NutTreeDriver = class {
+  _isInitialized = false;
+  _scaleFactor = 1;
+  // Lazy-loaded nut-tree modules
+  _nut = null;
+  // Cache of Window objects keyed by windowHandle, populated by getWindowList()
+  _windowCache = /* @__PURE__ */ new Map();
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  get scaleFactor() {
+    return this._scaleFactor;
+  }
+  async initialize() {
+    if (this._isInitialized) return;
+    try {
+      this._nut = await import('@nut-tree-fork/nut-js');
+    } catch {
+      throw new Error(
+        "@nut-tree-fork/nut-js is not installed. Install it to use desktop automation tools:\n  npm install @nut-tree-fork/nut-js"
+      );
+    }
+    try {
+      const { mouse, keyboard } = this._nut;
+      if (mouse.config) {
+        mouse.config.mouseSpeed = 1e4;
+        mouse.config.autoDelayMs = 0;
+      }
+      if (keyboard.config) {
+        keyboard.config.autoDelayMs = 0;
+      }
+    } catch {
+    }
+    try {
+      const { screen } = this._nut;
+      const logicalWidth = await screen.width();
+      const screenshotImage = await screen.grab();
+      const physicalWidth = screenshotImage.width;
+      this._scaleFactor = physicalWidth / logicalWidth;
+    } catch (err) {
+      if (err.message?.includes("permission") || err.message?.includes("accessibility")) {
+        throw new Error(
+          "Desktop automation requires accessibility permissions.\nOn macOS: System Settings \u2192 Privacy & Security \u2192 Accessibility \u2192 Enable your terminal app."
+        );
+      }
+      this._scaleFactor = 1;
+    }
+    this._isInitialized = true;
+  }
+  assertInitialized() {
+    if (!this._isInitialized) {
+      throw new Error("NutTreeDriver not initialized. Call initialize() first.");
+    }
+  }
+  /** Convert physical (screenshot) coords to logical (OS) coords */
+  toLogical(x, y) {
+    return {
+      x: Math.round(x / this._scaleFactor),
+      y: Math.round(y / this._scaleFactor)
+    };
+  }
+  /** Convert logical (OS) coords to physical (screenshot) coords */
+  toPhysical(x, y) {
+    return {
+      x: Math.round(x * this._scaleFactor),
+      y: Math.round(y * this._scaleFactor)
+    };
+  }
+  // ===== Screen =====
+  async screenshot(region) {
+    this.assertInitialized();
+    const { screen } = this._nut;
+    let image;
+    if (region) {
+      const { Region } = this._nut;
+      const logTopLeft = this.toLogical(region.x, region.y);
+      const logicalWidth = Math.round(region.width / this._scaleFactor);
+      const logicalHeight = Math.round(region.height / this._scaleFactor);
+      const nutRegion = new Region(logTopLeft.x, logTopLeft.y, logicalWidth, logicalHeight);
+      image = await screen.grabRegion(nutRegion);
+    } else {
+      image = await screen.grab();
+    }
+    const pngBuffer = await encodeRGBAToPNG(image.data, image.width, image.height);
+    const base64 = pngBuffer.toString("base64");
+    return {
+      base64,
+      width: image.width,
+      height: image.height
+    };
+  }
+  async getScreenSize() {
+    this.assertInitialized();
+    const { screen } = this._nut;
+    const logicalWidth = await screen.width();
+    const logicalHeight = await screen.height();
+    return {
+      physicalWidth: Math.round(logicalWidth * this._scaleFactor),
+      physicalHeight: Math.round(logicalHeight * this._scaleFactor),
+      logicalWidth,
+      logicalHeight,
+      scaleFactor: this._scaleFactor
+    };
+  }
+  // ===== Mouse =====
+  async mouseMove(x, y) {
+    this.assertInitialized();
+    const { mouse, straightTo, Point } = this._nut;
+    const logical = this.toLogical(x, y);
+    await mouse.move(straightTo(new Point(logical.x, logical.y)));
+  }
+  async mouseClick(x, y, button, clickCount) {
+    this.assertInitialized();
+    const { mouse, straightTo, Point, Button } = this._nut;
+    const nutButton = button === "right" ? Button.RIGHT : button === "middle" ? Button.MIDDLE : Button.LEFT;
+    const logical = this.toLogical(x, y);
+    await mouse.move(straightTo(new Point(logical.x, logical.y)));
+    for (let i = 0; i < clickCount; i++) {
+      await mouse.click(nutButton);
+    }
+  }
+  async mouseDrag(startX, startY, endX, endY, button) {
+    this.assertInitialized();
+    const { mouse, straightTo, Point, Button } = this._nut;
+    const nutButton = button === "right" ? Button.RIGHT : button === "middle" ? Button.MIDDLE : Button.LEFT;
+    const logicalStart = this.toLogical(startX, startY);
+    const logicalEnd = this.toLogical(endX, endY);
+    await mouse.move(straightTo(new Point(logicalStart.x, logicalStart.y)));
+    await mouse.pressButton(nutButton);
+    await mouse.move(straightTo(new Point(logicalEnd.x, logicalEnd.y)));
+    await mouse.releaseButton(nutButton);
+  }
+  async mouseScroll(deltaX, deltaY, x, y) {
+    this.assertInitialized();
+    const { mouse, straightTo, Point } = this._nut;
+    if (x !== void 0 && y !== void 0) {
+      const logical = this.toLogical(x, y);
+      await mouse.move(straightTo(new Point(logical.x, logical.y)));
+    }
+    if (deltaY !== 0) {
+      if (deltaY > 0) {
+        await mouse.scrollDown(Math.abs(deltaY));
+      } else {
+        await mouse.scrollUp(Math.abs(deltaY));
+      }
+    }
+    if (deltaX !== 0) {
+      if (deltaX > 0) {
+        await mouse.scrollRight(Math.abs(deltaX));
+      } else {
+        await mouse.scrollLeft(Math.abs(deltaX));
+      }
+    }
+  }
+  async getCursorPosition() {
+    this.assertInitialized();
+    const { mouse } = this._nut;
+    const pos = await mouse.getPosition();
+    return this.toPhysical(pos.x, pos.y);
+  }
+  // ===== Keyboard =====
+  async keyboardType(text, delay) {
+    this.assertInitialized();
+    const { keyboard } = this._nut;
+    const prevDelay = keyboard.config.autoDelayMs;
+    if (delay !== void 0) {
+      keyboard.config.autoDelayMs = delay;
+    }
+    try {
+      await keyboard.type(text);
+    } finally {
+      if (delay !== void 0) {
+        keyboard.config.autoDelayMs = prevDelay;
+      }
+    }
+  }
+  async keyboardKey(keys) {
+    this.assertInitialized();
+    const { keyboard, Key } = this._nut;
+    const parsedKeys = parseKeyCombo(keys, Key);
+    if (parsedKeys.length === 1) {
+      await keyboard.pressKey(parsedKeys[0]);
+      await keyboard.releaseKey(parsedKeys[0]);
+    } else {
+      for (const key of parsedKeys) {
+        await keyboard.pressKey(key);
+      }
+      for (const key of [...parsedKeys].reverse()) {
+        await keyboard.releaseKey(key);
+      }
+    }
+  }
+  // ===== Windows =====
+  async getWindowList() {
+    this.assertInitialized();
+    const { getWindows } = this._nut;
+    try {
+      const windows = await getWindows();
+      const result = [];
+      this._windowCache.clear();
+      for (const win of windows) {
+        try {
+          const handle = win.windowHandle;
+          if (handle === void 0 || handle === null) continue;
+          const title = await win.title;
+          const region = await win.region;
+          this._windowCache.set(handle, win);
+          result.push({
+            id: handle,
+            title: title || "",
+            bounds: region ? {
+              x: Math.round(region.left * this._scaleFactor),
+              y: Math.round(region.top * this._scaleFactor),
+              width: Math.round(region.width * this._scaleFactor),
+              height: Math.round(region.height * this._scaleFactor)
+            } : void 0
+          });
+        } catch {
+        }
+      }
+      return result;
+    } catch {
+      return [];
+    }
+  }
+  async focusWindow(windowId) {
+    this.assertInitialized();
+    let target = this._windowCache.get(windowId);
+    if (!target) {
+      const { getWindows } = this._nut;
+      const windows = await getWindows();
+      target = windows.find((w) => w.windowHandle === windowId);
+    }
+    if (!target) {
+      throw new Error(`Window with ID ${windowId} not found. Call desktop_window_list first to get current window IDs.`);
+    }
+    await target.focus();
+  }
+};
+
+// src/tools/desktop/getDriver.ts
+var defaultDriver = null;
+async function getDesktopDriver(config) {
+  if (config?.driver) {
+    if (!config.driver.isInitialized) {
+      await config.driver.initialize();
+    }
+    return config.driver;
+  }
+  if (!defaultDriver) {
+    defaultDriver = new NutTreeDriver();
+  }
+  if (!defaultDriver.isInitialized) {
+    await defaultDriver.initialize();
+  }
+  return defaultDriver;
+}
+function resetDefaultDriver() {
+  defaultDriver = null;
+}
+
+// src/tools/desktop/screenshot.ts
+function createDesktopScreenshotTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_screenshot",
+        description: `Take a screenshot of the entire screen or a specific region. Returns the screenshot image for visual analysis. Use this to see what's on screen before performing actions. IMPORTANT: If you capture a region, element positions in the image are relative to the region's top-left corner. To click an element at image position (ix, iy), you must use screen coordinates (ix + region.x, iy + region.y). Prefer full-screen screenshots to avoid coordinate offset errors.`,
+        parameters: {
+          type: "object",
+          properties: {
+            region: {
+              type: "object",
+              description: "Optional region to capture (in physical pixel coordinates). Omit to capture full screen.",
+              properties: {
+                x: { type: "number", description: "Left edge X coordinate" },
+                y: { type: "number", description: "Top edge Y coordinate" },
+                width: { type: "number", description: "Width in pixels" },
+                height: { type: "number", description: "Height in pixels" }
+              },
+              required: ["x", "y", "width", "height"]
+            }
+          },
+          required: []
+        }
+      }
+    },
+    describeCall: (args) => {
+      if (args.region) {
+        return `region (${args.region.x},${args.region.y}) ${args.region.width}x${args.region.height}`;
+      }
+      return "full screen";
+    },
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        const screenshot = await driver.screenshot(args.region);
+        return {
+          success: true,
+          width: screenshot.width,
+          height: screenshot.height,
+          base64: screenshot.base64,
+          __images: [{ base64: screenshot.base64, mediaType: "image/png" }],
+          // Include region info so the agent can compute screen coordinates:
+          // screen_x = image_x + regionOffsetX, screen_y = image_y + regionOffsetY
+          ...args.region ? { regionOffsetX: args.region.x, regionOffsetY: args.region.y } : {}
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopScreenshot = createDesktopScreenshotTool();
+
+// src/tools/desktop/mouseMove.ts
+function createDesktopMouseMoveTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_mouse_move",
+        description: `Move the mouse cursor to the specified (x, y) position. Coordinates are in screenshot pixel space (full screen). Returns the actual cursor position after the move for verification.`,
+        parameters: {
+          type: "object",
+          properties: {
+            x: { type: "number", description: "X coordinate (in screenshot pixels)" },
+            y: { type: "number", description: "Y coordinate (in screenshot pixels)" }
+          },
+          required: ["x", "y"]
+        }
+      }
+    },
+    describeCall: (args) => `(${args.x}, ${args.y})`,
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.mouseMove(args.x, args.y);
+        await applyHumanDelay(config ?? {});
+        const actual = await driver.getCursorPosition();
+        return { success: true, x: actual.x, y: actual.y };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopMouseMove = createDesktopMouseMoveTool();
+
+// src/tools/desktop/mouseClick.ts
+function createDesktopMouseClickTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_mouse_click",
+        description: `Click the mouse at the specified position or at the current cursor position. Supports left/right/middle button and single/double/triple click.`,
+        parameters: {
+          type: "object",
+          properties: {
+            x: { type: "number", description: "X coordinate to click (in screenshot pixels). Omit to click at current position." },
+            y: { type: "number", description: "Y coordinate to click (in screenshot pixels). Omit to click at current position." },
+            button: {
+              type: "string",
+              enum: ["left", "right", "middle"],
+              description: 'Mouse button to click. Default: "left"'
+            },
+            clickCount: {
+              type: "number",
+              description: "Number of clicks (1=single, 2=double, 3=triple). Default: 1"
+            }
+          },
+          required: []
+        }
+      }
+    },
+    describeCall: (args) => {
+      const pos = args.x !== void 0 ? `(${args.x}, ${args.y})` : "current position";
+      const btn = args.button && args.button !== "left" ? ` ${args.button}` : "";
+      const count = args.clickCount && args.clickCount > 1 ? ` x${args.clickCount}` : "";
+      return `${pos}${btn}${count}`;
+    },
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        const button = args.button ?? "left";
+        const clickCount = args.clickCount ?? 1;
+        if (args.x !== void 0 && args.y !== void 0) {
+          await driver.mouseClick(args.x, args.y, button, clickCount);
+        } else {
+          const pos = await driver.getCursorPosition();
+          await driver.mouseClick(pos.x, pos.y, button, clickCount);
+        }
+        await applyHumanDelay(config ?? {});
+        const actual = await driver.getCursorPosition();
+        return { success: true, x: actual.x, y: actual.y, button, clickCount };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopMouseClick = createDesktopMouseClickTool();
+
+// src/tools/desktop/mouseDrag.ts
+function createDesktopMouseDragTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_mouse_drag",
+        description: `Drag the mouse from one position to another. Presses the button at the start position, moves to the end position, then releases.`,
+        parameters: {
+          type: "object",
+          properties: {
+            startX: { type: "number", description: "Start X coordinate (in screenshot pixels)" },
+            startY: { type: "number", description: "Start Y coordinate (in screenshot pixels)" },
+            endX: { type: "number", description: "End X coordinate (in screenshot pixels)" },
+            endY: { type: "number", description: "End Y coordinate (in screenshot pixels)" },
+            button: {
+              type: "string",
+              enum: ["left", "right", "middle"],
+              description: 'Mouse button to use for dragging. Default: "left"'
+            }
+          },
+          required: ["startX", "startY", "endX", "endY"]
+        }
+      }
+    },
+    describeCall: (args) => `(${args.startX},${args.startY}) \u2192 (${args.endX},${args.endY})`,
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.mouseDrag(args.startX, args.startY, args.endX, args.endY, args.button ?? "left");
+        await applyHumanDelay(config ?? {});
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopMouseDrag = createDesktopMouseDragTool();
+
+// src/tools/desktop/mouseScroll.ts
+function createDesktopMouseScrollTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_mouse_scroll",
+        description: `Scroll the mouse wheel. Positive deltaY scrolls down, negative scrolls up. Positive deltaX scrolls right, negative scrolls left. Optionally specify position to scroll at.`,
+        parameters: {
+          type: "object",
+          properties: {
+            deltaX: { type: "number", description: "Horizontal scroll amount. Positive=right, negative=left. Default: 0" },
+            deltaY: { type: "number", description: "Vertical scroll amount. Positive=down, negative=up. Default: 0" },
+            x: { type: "number", description: "X coordinate to scroll at (in screenshot pixels). Omit to scroll at current position." },
+            y: { type: "number", description: "Y coordinate to scroll at (in screenshot pixels). Omit to scroll at current position." }
+          },
+          required: []
+        }
+      }
+    },
+    describeCall: (args) => {
+      const parts = [];
+      if (args.deltaY) parts.push(args.deltaY > 0 ? `down ${args.deltaY}` : `up ${Math.abs(args.deltaY)}`);
+      if (args.deltaX) parts.push(args.deltaX > 0 ? `right ${args.deltaX}` : `left ${Math.abs(args.deltaX)}`);
+      if (args.x !== void 0) parts.push(`at (${args.x},${args.y})`);
+      return parts.join(", ") || "no-op";
+    },
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.mouseScroll(args.deltaX ?? 0, args.deltaY ?? 0, args.x, args.y);
+        await applyHumanDelay(config ?? {});
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopMouseScroll = createDesktopMouseScrollTool();
+
+// src/tools/desktop/getCursor.ts
+function createDesktopGetCursorTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_get_cursor",
+        description: `Get the current mouse cursor position in screenshot pixel coordinates.`,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    },
+    describeCall: () => "get cursor position",
+    execute: async () => {
+      try {
+        const driver = await getDesktopDriver(config);
+        const pos = await driver.getCursorPosition();
+        return { success: true, x: pos.x, y: pos.y };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopGetCursor = createDesktopGetCursorTool();
+
+// src/tools/desktop/keyboardType.ts
+function createDesktopKeyboardTypeTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_keyboard_type",
+        description: `Type text using the keyboard. Each character is typed as a keypress. Use this for entering text into focused input fields.`,
+        parameters: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The text to type" },
+            delay: { type: "number", description: "Delay in ms between each keystroke. Default: uses system default." }
+          },
+          required: ["text"]
+        }
+      }
+    },
+    describeCall: (args) => {
+      const preview = args.text.length > 30 ? args.text.slice(0, 27) + "..." : args.text;
+      return `"${preview}"`;
+    },
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.keyboardType(args.text, args.delay);
+        await applyHumanDelay(config ?? {});
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopKeyboardType = createDesktopKeyboardTypeTool();
+
+// src/tools/desktop/keyboardKey.ts
+function createDesktopKeyboardKeyTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_keyboard_key",
+        description: `Press a keyboard shortcut or special key. Use "+" to combine keys (e.g., "ctrl+c", "cmd+shift+s", "enter", "tab", "escape"). Modifiers: ctrl, cmd/command, alt/option, shift. Special keys: enter, tab, escape, backspace, delete, space, up, down, left, right, f1-f12, home, end, pageup, pagedown.`,
+        parameters: {
+          type: "object",
+          properties: {
+            keys: {
+              type: "string",
+              description: 'Key combo string (e.g., "ctrl+c", "enter", "cmd+shift+s")'
+            }
+          },
+          required: ["keys"]
+        }
+      }
+    },
+    describeCall: (args) => args.keys,
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.keyboardKey(args.keys);
+        await applyHumanDelay(config ?? {});
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopKeyboardKey = createDesktopKeyboardKeyTool();
+
+// src/tools/desktop/getScreenSize.ts
+function createDesktopGetScreenSizeTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_get_screen_size",
+        description: `Get the screen dimensions. Returns physical pixel size (screenshot space), logical size (OS coordinates), and the scale factor (e.g., 2.0 on Retina displays). All desktop tool coordinates use physical pixel space.`,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    },
+    describeCall: () => "get screen size",
+    execute: async () => {
+      try {
+        const driver = await getDesktopDriver(config);
+        const size = await driver.getScreenSize();
+        return {
+          success: true,
+          physicalWidth: size.physicalWidth,
+          physicalHeight: size.physicalHeight,
+          logicalWidth: size.logicalWidth,
+          logicalHeight: size.logicalHeight,
+          scaleFactor: size.scaleFactor
+        };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopGetScreenSize = createDesktopGetScreenSizeTool();
+
+// src/tools/desktop/windowList.ts
+function createDesktopWindowListTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_window_list",
+        description: `List all visible windows on the desktop. Returns window IDs, titles, application names, and bounds. Use the window ID with desktop_window_focus to bring a window to the foreground.`,
+        parameters: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      }
+    },
+    describeCall: () => "list windows",
+    execute: async () => {
+      try {
+        const driver = await getDesktopDriver(config);
+        const windows = await driver.getWindowList();
+        return { success: true, windows };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopWindowList = createDesktopWindowListTool();
+
+// src/tools/desktop/windowFocus.ts
+function createDesktopWindowFocusTool(config) {
+  return {
+    definition: {
+      type: "function",
+      function: {
+        name: "desktop_window_focus",
+        description: `Focus (bring to front) a window by its ID. Use desktop_window_list to get available window IDs.`,
+        parameters: {
+          type: "object",
+          properties: {
+            windowId: {
+              type: "number",
+              description: "The window ID from desktop_window_list"
+            }
+          },
+          required: ["windowId"]
+        }
+      }
+    },
+    describeCall: (args) => `window ${args.windowId}`,
+    execute: async (args) => {
+      try {
+        const driver = await getDesktopDriver(config);
+        await driver.focusWindow(args.windowId);
+        return { success: true };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  };
+}
+var desktopWindowFocus = createDesktopWindowFocusTool();
+
+// src/tools/desktop/index.ts
+var desktopTools = [
+  desktopScreenshot,
+  desktopMouseMove,
+  desktopMouseClick,
+  desktopMouseDrag,
+  desktopMouseScroll,
+  desktopGetCursor,
+  desktopKeyboardType,
+  desktopKeyboardKey,
+  desktopGetScreenSize,
+  desktopWindowList,
+  desktopWindowFocus
+];
+
 // src/tools/registry.generated.ts
 var toolRegistry = [
   {
@@ -49591,6 +51702,105 @@ var toolRegistry = [
     tool: executeJavaScript,
     safeByDefault: false
   },
+  {
+    name: "desktop_get_cursor",
+    exportName: "desktopGetCursor",
+    displayName: "Desktop Get Cursor",
+    category: "desktop",
+    description: "Get the current mouse cursor position in screenshot pixel coordinates.",
+    tool: desktopGetCursor,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_get_screen_size",
+    exportName: "desktopGetScreenSize",
+    displayName: "Desktop Get Screen Size",
+    category: "desktop",
+    description: "Get the screen dimensions. Returns physical pixel size (screenshot space), logical size (OS coordinates), and the scale factor (e.g., 2.0 on Retina displays). All desktop tool coordinates use physical",
+    tool: desktopGetScreenSize,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_keyboard_key",
+    exportName: "desktopKeyboardKey",
+    displayName: "Desktop Keyboard Key",
+    category: "desktop",
+    description: 'Press a keyboard shortcut or special key. Use "+" to combine keys (e.g., "ctrl+c", "cmd+shift+s", "enter", "tab", "escape"). Modifiers: ctrl, cmd/command, alt/option, shift. Special keys: enter, tab, ',
+    tool: desktopKeyboardKey,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_keyboard_type",
+    exportName: "desktopKeyboardType",
+    displayName: "Desktop Keyboard Type",
+    category: "desktop",
+    description: "Type text using the keyboard. Each character is typed as a keypress. Use this for entering text into focused input fields.",
+    tool: desktopKeyboardType,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_mouse_click",
+    exportName: "desktopMouseClick",
+    displayName: "Desktop Mouse Click",
+    category: "desktop",
+    description: "Click the mouse at the specified position or at the current cursor position. Supports left/right/middle button and single/double/triple click.",
+    tool: desktopMouseClick,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_mouse_drag",
+    exportName: "desktopMouseDrag",
+    displayName: "Desktop Mouse Drag",
+    category: "desktop",
+    description: "Drag the mouse from one position to another. Presses the button at the start position, moves to the end position, then releases.",
+    tool: desktopMouseDrag,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_mouse_move",
+    exportName: "desktopMouseMove",
+    displayName: "Desktop Mouse Move",
+    category: "desktop",
+    description: "Move the mouse cursor to the specified (x, y) position. Coordinates are in screenshot pixel space (full screen). Returns the actual cursor position after the move for verification.",
+    tool: desktopMouseMove,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_mouse_scroll",
+    exportName: "desktopMouseScroll",
+    displayName: "Desktop Mouse Scroll",
+    category: "desktop",
+    description: "Scroll the mouse wheel. Positive deltaY scrolls down, negative scrolls up. Positive deltaX scrolls right, negative scrolls left. Optionally specify position to scroll at.",
+    tool: desktopMouseScroll,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_screenshot",
+    exportName: "desktopScreenshot",
+    displayName: "Desktop Screenshot",
+    category: "desktop",
+    description: "Take a screenshot of the entire screen or a specific region. Returns the screenshot image for visual analysis. Use this to see what's on screen before performing actions. IMPORTANT: If you capture a r",
+    tool: desktopScreenshot,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_window_focus",
+    exportName: "desktopWindowFocus",
+    displayName: "Desktop Window Focus",
+    category: "desktop",
+    description: "Focus (bring to front) a window by its ID. Use desktop_window_list to get available window IDs.",
+    tool: desktopWindowFocus,
+    safeByDefault: false
+  },
+  {
+    name: "desktop_window_list",
+    exportName: "desktopWindowList",
+    displayName: "Desktop Window List",
+    category: "desktop",
+    description: "List all visible windows on the desktop. Returns window IDs, titles, application names, and bounds. Use the window ID with desktop_window_focus to bring a window to the foreground.",
+    tool: desktopWindowList,
+    safeByDefault: false
+  },
   {
     name: "edit_file",
     exportName: "editFile",
@@ -49632,7 +51842,7 @@ var toolRegistry = [
     exportName: "readFile",
     displayName: "Read File",
     category: "filesystem",
-    description: "Read content from a file on the local filesystem.",
+    description: "Read content from a file on the local filesystem. Supports text files AND binary document formats \u2014 PDF, DOCX, PPTX, XLSX, ODS, ODT, ODP, and images (PNG, JPG, GIF, WEBP) are automatically converted t",
     tool: readFile5,
     safeByDefault: true
   },
@@ -49668,7 +51878,7 @@ var toolRegistry = [
     exportName: "webFetch",
     displayName: "Web Fetch",
     category: "web",
-    description: "Fetch and extract text content from a web page URL.",
+    description: "Fetch and extract content from a URL \u2014 works with web pages AND document files (PDF, DOCX, XLSX, PPTX, etc.). Document URLs are automatically detected and converted to markdown text.",
     tool: webFetch,
     safeByDefault: true
   }
@@ -50050,6 +52260,7 @@ exports.DEFAULT_ALLOWLIST = DEFAULT_ALLOWLIST;
 exports.DEFAULT_CHECKPOINT_STRATEGY = DEFAULT_CHECKPOINT_STRATEGY;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG2;
 exports.DEFAULT_CONTEXT_CONFIG = DEFAULT_CONTEXT_CONFIG;
+exports.DEFAULT_DESKTOP_CONFIG = DEFAULT_DESKTOP_CONFIG;
 exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
 exports.DEFAULT_FILESYSTEM_CONFIG = DEFAULT_FILESYSTEM_CONFIG;
 exports.DEFAULT_HISTORY_MANAGER_CONFIG = DEFAULT_HISTORY_MANAGER_CONFIG;
@@ -50057,8 +52268,10 @@ exports.DEFAULT_MEMORY_CONFIG = DEFAULT_MEMORY_CONFIG;
 exports.DEFAULT_PERMISSION_CONFIG = DEFAULT_PERMISSION_CONFIG;
 exports.DEFAULT_RATE_LIMITER_CONFIG = DEFAULT_RATE_LIMITER_CONFIG;
 exports.DEFAULT_SHELL_CONFIG = DEFAULT_SHELL_CONFIG;
+exports.DESKTOP_TOOL_NAMES = DESKTOP_TOOL_NAMES;
 exports.DefaultCompactionStrategy = DefaultCompactionStrategy;
 exports.DependencyCycleError = DependencyCycleError;
+exports.DocumentReader = DocumentReader;
 exports.ErrorHandler = ErrorHandler;
 exports.ExecutionContext = ExecutionContext;
 exports.ExternalDependencyHandler = ExternalDependencyHandler;
@@ -50069,6 +52282,7 @@ exports.FileMediaOutputHandler = FileMediaStorage;
 exports.FileMediaStorage = FileMediaStorage;
 exports.FilePersistentInstructionsStorage = FilePersistentInstructionsStorage;
 exports.FileStorage = FileStorage;
+exports.FormatDetector = FormatDetector;
 exports.HookManager = HookManager;
 exports.IMAGE_MODELS = IMAGE_MODELS;
 exports.IMAGE_MODEL_REGISTRY = IMAGE_MODEL_REGISTRY;
@@ -50097,6 +52311,7 @@ exports.MemoryEvictionCompactor = MemoryEvictionCompactor;
 exports.MessageBuilder = MessageBuilder;
 exports.MessageRole = MessageRole;
 exports.ModelNotSupportedError = ModelNotSupportedError;
+exports.NutTreeDriver = NutTreeDriver;
 exports.ParallelTasksError = ParallelTasksError;
 exports.PersistentInstructionsPluginNextGen = PersistentInstructionsPluginNextGen;
 exports.PlanningAgent = PlanningAgent;
@@ -50173,6 +52388,17 @@ exports.createAuthenticatedFetch = createAuthenticatedFetch;
 exports.createBashTool = createBashTool;
 exports.createConnectorFromTemplate = createConnectorFromTemplate;
 exports.createCreatePRTool = createCreatePRTool;
+exports.createDesktopGetCursorTool = createDesktopGetCursorTool;
+exports.createDesktopGetScreenSizeTool = createDesktopGetScreenSizeTool;
+exports.createDesktopKeyboardKeyTool = createDesktopKeyboardKeyTool;
+exports.createDesktopKeyboardTypeTool = createDesktopKeyboardTypeTool;
+exports.createDesktopMouseClickTool = createDesktopMouseClickTool;
+exports.createDesktopMouseDragTool = createDesktopMouseDragTool;
+exports.createDesktopMouseMoveTool = createDesktopMouseMoveTool;
+exports.createDesktopMouseScrollTool = createDesktopMouseScrollTool;
+exports.createDesktopScreenshotTool = createDesktopScreenshotTool;
+exports.createDesktopWindowFocusTool = createDesktopWindowFocusTool;
+exports.createDesktopWindowListTool = createDesktopWindowListTool;
 exports.createEditFileTool = createEditFileTool;
 exports.createEstimator = createEstimator;
 exports.createExecuteJavaScriptTool = createExecuteJavaScriptTool;
@@ -50203,9 +52429,22 @@ exports.createVideoProvider = createVideoProvider;
 exports.createVideoTools = createVideoTools;
 exports.createWriteFileTool = createWriteFileTool;
 exports.defaultDescribeCall = defaultDescribeCall;
+exports.desktopGetCursor = desktopGetCursor;
+exports.desktopGetScreenSize = desktopGetScreenSize;
+exports.desktopKeyboardKey = desktopKeyboardKey;
+exports.desktopKeyboardType = desktopKeyboardType;
+exports.desktopMouseClick = desktopMouseClick;
+exports.desktopMouseDrag = desktopMouseDrag;
+exports.desktopMouseMove = desktopMouseMove;
+exports.desktopMouseScroll = desktopMouseScroll;
+exports.desktopScreenshot = desktopScreenshot;
+exports.desktopTools = desktopTools;
+exports.desktopWindowFocus = desktopWindowFocus;
+exports.desktopWindowList = desktopWindowList;
 exports.detectDependencyCycle = detectDependencyCycle;
 exports.detectServiceFromURL = detectServiceFromURL;
 exports.developerTools = developerTools;
+exports.documentToContent = documentToContent;
 exports.editFile = editFile;
 exports.evaluateCondition = evaluateCondition;
 exports.extractJSON = extractJSON;
@@ -50229,6 +52468,7 @@ exports.getAllVendorTemplates = getAllVendorTemplates;
 exports.getBackgroundOutput = getBackgroundOutput;
 exports.getConnectorTools = getConnectorTools;
 exports.getCredentialsSetupURL = getCredentialsSetupURL;
+exports.getDesktopDriver = getDesktopDriver;
 exports.getDocsURL = getDocsURL;
 exports.getImageModelInfo = getImageModelInfo;
 exports.getImageModelsByVendor = getImageModelsByVendor;
@@ -50296,10 +52536,14 @@ exports.listVendors = listVendors;
 exports.listVendorsByAuthType = listVendorsByAuthType;
 exports.listVendorsByCategory = listVendorsByCategory;
 exports.listVendorsWithLogos = listVendorsWithLogos;
+exports.mergeTextPieces = mergeTextPieces;
+exports.parseKeyCombo = parseKeyCombo;
 exports.parseRepository = parseRepository;
 exports.readClipboardImage = readClipboardImage;
+exports.readDocumentAsContent = readDocumentAsContent;
 exports.readFile = readFile5;
 exports.registerScrapeProvider = registerScrapeProvider;
+exports.resetDefaultDriver = resetDefaultDriver;
 exports.resolveConnector = resolveConnector;
 exports.resolveDependencies = resolveDependencies;
 exports.resolveRepository = resolveRepository;