@probelabs/probe 0.6.0-rc259 → 0.6.0-rc261

package/build/agent/index.js

@@ -12238,6 +12238,10 @@ function parseSimpleCommand(command) {
     // Logical OR
     /(?<!\\);/,
     // Command separator (but not escaped \;)
+    /\n/,
+    // Newline command separator (multi-line commands)
+    /\r/,
+    // Carriage return (CRLF line endings)
     /&$/,
     // Background execution
     /\$\(/,
@@ -12344,6 +12348,8 @@ function isComplexPattern(pattern) {
     // Logical OR
     /;/,
     // Command separator
+    /\n/,
+    // Newline command separator
     /&$/,
     // Background execution
     /\$\(/,
@@ -12716,6 +12722,26 @@ var init_bashPermissions = __esm({
               i++;
               continue;
             }
+            if (char === "\n" || char === "\r" && nextChar === "\n") {
+              if (current2.trim()) {
+                components.push(current2.trim());
+              }
+              current2 = "";
+              if (char === "\r") {
+                i += 2;
+              } else {
+                i++;
+              }
+              continue;
+            }
+            if (char === "\r") {
+              if (current2.trim()) {
+                components.push(current2.trim());
+              }
+              current2 = "";
+              i++;
+              continue;
+            }
           }
           current2 += char;
           i++;
@@ -23270,31 +23296,33 @@ var init_runtime = __esm({
   }
 });
 
-// node_modules/balanced-match/dist/esm/index.js
-var balanced, maybeMatch, range;
-var init_esm = __esm({
-  "node_modules/balanced-match/dist/esm/index.js"() {
-    balanced = (a, b, str) => {
-      const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-      const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-      const r = ma !== null && mb != null && range(ma, mb, str);
+// node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "node_modules/balanced-match/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch(a, str);
+      if (b instanceof RegExp) b = maybeMatch(b, str);
+      var r = range(a, b, str);
       return r && {
         start: r[0],
         end: r[1],
         pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + ma.length, r[1]),
-        post: str.slice(r[1] + mb.length)
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
       };
-    };
-    maybeMatch = (reg, str) => {
-      const m = str.match(reg);
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
       return m ? m[0] : null;
-    };
-    range = (a, b, str) => {
-      let begs, beg, left, right = void 0, result;
-      let ai = str.indexOf(a);
-      let bi = str.indexOf(b, ai + 1);
-      let i = ai;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
       if (ai >= 0 && bi > 0) {
         if (a === b) {
           return [ai, bi];
@@ -23302,16 +23330,14 @@ var init_esm = __esm({
         begs = [];
         left = str.length;
         while (i >= 0 && !result) {
-          if (i === ai) {
+          if (i == ai) {
             begs.push(i);
             ai = str.indexOf(a, i + 1);
-          } else if (begs.length === 1) {
-            const r = begs.pop();
-            if (r !== void 0)
-              result = [r, bi];
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
           } else {
             beg = begs.pop();
-            if (beg !== void 0 && beg < left) {
+            if (beg < left) {
               left = beg;
               right = bi;
             }
@@ -23319,179 +23345,163 @@ var init_esm = __esm({
           }
           i = ai < bi && ai >= 0 ? ai : bi;
         }
-        if (begs.length && right !== void 0) {
+        if (begs.length) {
           result = [left, right];
         }
       }
       return result;
-    };
+    }
   }
 });
 
-// node_modules/brace-expansion/dist/esm/index.js
-function numeric(str) {
-  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function parseCommaParts(str) {
-  if (!str) {
-    return [""];
-  }
-  const parts = [];
-  const m = balanced("{", "}", str);
-  if (!m) {
-    return str.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    ;
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str, options = {}) {
-  if (!str) {
-    return [];
-  }
-  const { max = EXPANSION_MAX } = options;
-  if (str.slice(0, 2) === "{}") {
-    str = "\\{\\}" + str.slice(2);
-  }
-  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
-}
-function embrace(str) {
-  return "{" + str + "}";
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-  return i <= y;
-}
-function gte(i, y) {
-  return i >= y;
-}
-function expand_(str, max, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str);
-  if (!m)
-    return [str];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, max, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k = 0; k < post.length && k < max; k++) {
-      const expansion = pre + "{" + m.body + "}" + post[k];
-      expansions.push(expansion);
+// node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "node_modules/brace-expansion/index.js"(exports2, module2) {
+    var balanced = require_balanced_match();
+    module2.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand2(escapeBraces(str), true).map(unescapeBraces);
     }
-  } else {
-    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    const isSequence = isNumericSequence || isAlphaSequence;
-    const isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str, max, true);
-      }
-      return [str];
-    }
-    let n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1 && n[0] !== void 0) {
-        n = expand_(n[0], max, false).map(embrace);
-        if (n.length === 1) {
-          return post.map((p) => m.pre + n[0] + p);
-        }
-      }
-    }
-    let N;
-    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-      const x = numeric(n[0]);
-      const y = numeric(n[1]);
-      const width = Math.max(n[0].length, n[1].length);
-      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
-      let test = lte;
-      const reverse = y < x;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n.some(isPadded);
-      N = [];
-      for (let i = x; test(i, y); i += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\") {
-            c = "";
-          }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand2(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m) return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand2(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
+        }
+      } else {
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,(?!,).*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
         } else {
-          c = String(i);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z = new Array(need + 1).join("0");
-              if (i < 0) {
-                c = "-" + z + c.slice(1);
-              } else {
-                c = z + c;
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand2(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
               }
             }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
           }
         }
-        N.push(c);
-      }
-    } else {
-      N = [];
-      for (let j = 0; j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], max, false));
-      }
-    }
-    for (let j = 0; j < N.length; j++) {
-      for (let k = 0; k < post.length && expansions.length < max; k++) {
-        const expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
         }
       }
+      return expansions;
     }
   }
-  return expansions;
-}
-var escSlash, escOpen, escClose, escComma, escPeriod, escSlashPattern, escOpenPattern, escClosePattern, escCommaPattern, escPeriodPattern, slashPattern, openPattern, closePattern, commaPattern, periodPattern, EXPANSION_MAX;
-var init_esm2 = __esm({
-  "node_modules/brace-expansion/dist/esm/index.js"() {
-    init_esm();
-    escSlash = "\0SLASH" + Math.random() + "\0";
-    escOpen = "\0OPEN" + Math.random() + "\0";
-    escClose = "\0CLOSE" + Math.random() + "\0";
-    escComma = "\0COMMA" + Math.random() + "\0";
-    escPeriod = "\0PERIOD" + Math.random() + "\0";
-    escSlashPattern = new RegExp(escSlash, "g");
-    escOpenPattern = new RegExp(escOpen, "g");
-    escClosePattern = new RegExp(escClose, "g");
-    escCommaPattern = new RegExp(escComma, "g");
-    escPeriodPattern = new RegExp(escPeriod, "g");
-    slashPattern = /\\\\/g;
-    openPattern = /\\{/g;
-    closePattern = /\\}/g;
-    commaPattern = /\\,/g;
-    periodPattern = /\\./g;
-    EXPANSION_MAX = 1e5;
-  }
 });
 
 // node_modules/minimatch/dist/esm/assert-valid-pattern.js
@@ -24263,10 +24273,10 @@ var init_escape = __esm({
 });
 
 // node_modules/minimatch/dist/esm/index.js
-var minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep3, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
-var init_esm3 = __esm({
+var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep3, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var init_esm = __esm({
   "node_modules/minimatch/dist/esm/index.js"() {
-    init_esm2();
+    import_brace_expansion = __toESM(require_brace_expansion(), 1);
     init_assert_valid_pattern();
     init_ast();
     init_escape();
@@ -24389,7 +24399,7 @@ var init_esm3 = __esm({
       if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
-      return expand(pattern);
+      return (0, import_brace_expansion.default)(pattern);
     };
     minimatch.braceExpand = braceExpand;
     makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
@@ -24794,7 +24804,11 @@ var init_esm3 = __esm({
       #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
         const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
         const lastgs = pattern.lastIndexOf(GLOBSTAR);
-        const [head2, body, tail] = [
+        const [head2, body, tail] = partial ? [
+          pattern.slice(patternIndex, firstgs),
+          pattern.slice(firstgs + 1),
+          []
+        ] : [
           pattern.slice(patternIndex, firstgs),
           pattern.slice(firstgs + 1, lastgs),
           pattern.slice(lastgs + 1)
@@ -24831,7 +24845,7 @@ var init_esm3 = __esm({
               return false;
             }
           }
-          return sawSome;
+          return partial || sawSome;
         }
         const bodySegments = [[[], 0]];
         let currentBody = bodySegments[0];
@@ -24880,7 +24894,7 @@ var init_esm3 = __esm({
           }
           fileIndex++;
         }
-        return null;
+        return partial || null;
       }
       #matchOne(file, pattern, partial, fileIndex, patternIndex) {
         let fi;
@@ -25061,7 +25075,7 @@ var init_esm3 = __esm({
 
 // node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js
 var perf, warned, PROCESS, emitWarning, AC, AS, shouldWarn, TYPE, isPosInt, getUintArray, ZeroArray, Stack, LRUCache;
-var init_esm4 = __esm({
+var init_esm2 = __esm({
   "node_modules/path-scurry/node_modules/lru-cache/dist/esm/index.js"() {
     perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
     warned = /* @__PURE__ */ new Set();
@@ -26438,7 +26452,7 @@ import { EventEmitter } from "node:events";
 import Stream from "node:stream";
 import { StringDecoder } from "node:string_decoder";
 var proc, isStream, isReadable, isWritable, EOF, MAYBE_EMIT_END, EMITTED_END, EMITTING_END, EMITTED_ERROR, CLOSED, READ, FLUSH, FLUSHCHUNK, ENCODING, DECODER, FLOWING, PAUSED, RESUME, BUFFER, PIPES, BUFFERLENGTH, BUFFERPUSH, BUFFERSHIFT, OBJECTMODE, DESTROYED, ERROR, EMITDATA, EMITEND, EMITEND2, ASYNC, ABORT, ABORTED, SIGNAL, DATALISTENERS, DISCARDED, defer, nodefer, isEndish, isArrayBufferLike, isArrayBufferView, Pipe, PipeProxyErrors, isObjectModeOptions, isEncodingOptions, Minipass;
-var init_esm5 = __esm({
+var init_esm3 = __esm({
   "node_modules/minipass/dist/esm/index.js"() {
     proc = typeof process === "object" && process ? process : {
       stdout: null,
@@ -27327,10 +27341,10 @@ import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSyn
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
 var realpathSync2, defaultFS, fsFromOption, uncDriveRegexp, uncToDrive, eitherSep, UNKNOWN, IFIFO, IFCHR, IFDIR, IFBLK, IFREG, IFLNK, IFSOCK, IFMT, IFMT_UNKNOWN, READDIR_CALLED, LSTAT_CALLED, ENOTDIR, ENOENT, ENOREADLINK, ENOREALPATH, ENOCHILD, TYPEMASK, entToType, normalizeCache, normalize, normalizeNocaseCache, normalizeNocase, ResolveCache, ChildrenCache, setAsCwd, PathBase, PathWin32, PathPosix, PathScurryBase, PathScurryWin32, PathScurryPosix, PathScurryDarwin, Path, PathScurry;
-var init_esm6 = __esm({
+var init_esm4 = __esm({
   "node_modules/path-scurry/dist/esm/index.js"() {
-    init_esm4();
-    init_esm5();
+    init_esm2();
+    init_esm3();
     realpathSync2 = rps.native;
     defaultFS = {
       lstatSync,
@@ -29060,7 +29074,7 @@ var init_esm6 = __esm({
 var isPatternList, isGlobList, Pattern;
 var init_pattern = __esm({
   "node_modules/glob/dist/esm/pattern.js"() {
-    init_esm3();
+    init_esm();
     isPatternList = (pl) => pl.length >= 1;
     isGlobList = (gl) => gl.length >= 1;
     Pattern = class _Pattern {
@@ -29231,7 +29245,7 @@ var init_pattern = __esm({
 var defaultPlatform2, Ignore;
 var init_ignore = __esm({
   "node_modules/glob/dist/esm/ignore.js"() {
-    init_esm3();
+    init_esm();
     init_pattern();
     defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
     Ignore = class {
@@ -29325,7 +29339,7 @@ var init_ignore = __esm({
 var HasWalkedCache, MatchRecord, SubWalks, Processor;
 var init_processor = __esm({
   "node_modules/glob/dist/esm/processor.js"() {
-    init_esm3();
+    init_esm();
     HasWalkedCache = class _HasWalkedCache {
       store;
       constructor(store = /* @__PURE__ */ new Map()) {
@@ -29552,7 +29566,7 @@ var init_processor = __esm({
 var makeIgnore, GlobUtil, GlobWalker, GlobStream;
 var init_walker = __esm({
   "node_modules/glob/dist/esm/walker.js"() {
-    init_esm5();
+    init_esm3();
     init_ignore();
     init_processor();
     makeIgnore = (ignore2, opts) => typeof ignore2 === "string" ? new Ignore([ignore2], opts) : Array.isArray(ignore2) ? new Ignore(ignore2, opts) : ignore2;
@@ -29888,8 +29902,8 @@ import { fileURLToPath as fileURLToPath5 } from "node:url";
 var defaultPlatform3, Glob;
 var init_glob = __esm({
   "node_modules/glob/dist/esm/glob.js"() {
-    init_esm3();
-    init_esm6();
+    init_esm();
+    init_esm4();
     init_pattern();
     init_walker();
     defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
@@ -30097,7 +30111,7 @@ var init_glob = __esm({
 var hasMagic;
 var init_has_magic = __esm({
   "node_modules/glob/dist/esm/has-magic.js"() {
-    init_esm3();
+    init_esm();
     hasMagic = (pattern, options = {}) => {
       if (!Array.isArray(pattern)) {
         pattern = [pattern];
@@ -30131,12 +30145,12 @@ function globIterate(pattern, options = {}) {
   return new Glob(pattern, options).iterate();
 }
 var streamSync, stream, iterateSync, iterate, sync, glob;
-var init_esm7 = __esm({
+var init_esm5 = __esm({
   "node_modules/glob/dist/esm/index.js"() {
-    init_esm3();
+    init_esm();
     init_glob();
     init_has_magic();
-    init_esm3();
+    init_esm();
     init_glob();
     init_has_magic();
     init_ignore();
@@ -31096,7 +31110,7 @@ var init_executePlan = __esm({
     init_query();
     init_extract();
     init_delegate();
-    init_esm7();
+    init_esm5();
     init_bash();
     RAW_OUTPUT_START = "<<<RAW_OUTPUT>>>";
     RAW_OUTPUT_END = "<<<END_RAW_OUTPUT>>>";
@@ -32185,7 +32199,7 @@ var init_probeTool = __esm({
   "src/agent/probeTool.js"() {
     "use strict";
     init_index();
-    init_esm7();
+    init_esm5();
     init_symlink_utils();
     toolCallEmitter = new EventEmitter2();
     activeToolExecutions = /* @__PURE__ */ new Map();
@@ -32935,13 +32949,13 @@ var init_index = __esm({
 });
 
 // src/agent/xmlParsingUtils.js
-function removeThinkingTags(xmlString) {
+function removeThinkingTags(xmlString, validTools = DEFAULT_VALID_TOOLS) {
   let result = xmlString;
   result = result.replace(/<thinking>[\s\S]*?<\/thinking>/g, "");
   const thinkingIndex = result.indexOf("<thinking>");
   if (thinkingIndex !== -1) {
     const afterThinking = result.substring(thinkingIndex + "<thinking>".length);
-    const toolPattern = buildToolTagPattern(DEFAULT_VALID_TOOLS);
+    const toolPattern = buildToolTagPattern(validTools);
     const toolMatch = afterThinking.match(toolPattern);
     if (toolMatch) {
       const toolStart = thinkingIndex + "<thinking>".length + toolMatch.index;
@@ -33040,7 +33054,7 @@ function hasOtherToolTags(xmlString, validTools = []) {
 }
 function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
   const thinkingContent = extractThinkingContent(xmlString);
-  const cleanedXmlString = removeThinkingTags(xmlString);
+  const cleanedXmlString = removeThinkingTags(xmlString, validTools.length > 0 ? validTools : void 0);
   const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
   if (process.env.DEBUG === "1" && thinkingContent) {
     console.log(`[DEBUG] AI Thinking Process:
@@ -38442,23 +38456,23 @@ var init_regexp_parser = __esm({
         return ASSERT_NEVER_REACH_HERE();
       }
       quantifier(isBacktracking = false) {
-        let range2 = void 0;
+        let range = void 0;
         const begin = this.idx;
         switch (this.popChar()) {
           case "*":
-            range2 = {
+            range = {
               atLeast: 0,
               atMost: Infinity
             };
             break;
           case "+":
-            range2 = {
+            range = {
               atLeast: 1,
               atMost: Infinity
             };
             break;
           case "?":
-            range2 = {
+            range = {
               atLeast: 0,
               atMost: 1
             };
@@ -38467,7 +38481,7 @@ var init_regexp_parser = __esm({
             const atLeast = this.integerIncludingZero();
             switch (this.popChar()) {
               case "}":
-                range2 = {
+                range = {
                   atLeast,
                   atMost: atLeast
                 };
@@ -38476,12 +38490,12 @@ var init_regexp_parser = __esm({
                 let atMost;
                 if (this.isDigit()) {
                   atMost = this.integerIncludingZero();
-                  range2 = {
+                  range = {
                     atLeast,
                     atMost
                   };
                 } else {
-                  range2 = {
+                  range = {
                     atLeast,
                     atMost: Infinity
                   };
@@ -38489,25 +38503,25 @@ var init_regexp_parser = __esm({
                 this.consumeChar("}");
                 break;
             }
-            if (isBacktracking === true && range2 === void 0) {
+            if (isBacktracking === true && range === void 0) {
               return void 0;
             }
-            ASSERT_EXISTS(range2);
+            ASSERT_EXISTS(range);
             break;
         }
-        if (isBacktracking === true && range2 === void 0) {
+        if (isBacktracking === true && range === void 0) {
           return void 0;
         }
-        if (ASSERT_EXISTS(range2)) {
+        if (ASSERT_EXISTS(range)) {
           if (this.peekChar(0) === "?") {
             this.consumeChar("?");
-            range2.greedy = false;
+            range.greedy = false;
           } else {
-            range2.greedy = true;
+            range.greedy = true;
           }
-          range2.type = "Quantifier";
-          range2.loc = this.loc(begin);
-          return range2;
+          range.type = "Quantifier";
+          range.loc = this.loc(begin);
+          return range;
         }
       }
       atom() {
@@ -39209,18 +39223,18 @@ function firstCharOptimizedIndices(ast, result, ignoreCase) {
               if (typeof code === "number") {
                 addOptimizedIdxToResult(code, result, ignoreCase);
               } else {
-                const range2 = code;
+                const range = code;
                 if (ignoreCase === true) {
-                  for (let rangeCode = range2.from; rangeCode <= range2.to; rangeCode++) {
+                  for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
                 } else {
-                  for (let rangeCode = range2.from; rangeCode <= range2.to && rangeCode < minOptimizationVal; rangeCode++) {
+                  for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {
                     addOptimizedIdxToResult(rangeCode, result, ignoreCase);
                   }
-                  if (range2.to >= minOptimizationVal) {
-                    const minUnOptVal = range2.from >= minOptimizationVal ? range2.from : minOptimizationVal;
-                    const maxUnOptVal = range2.to;
+                  if (range.to >= minOptimizationVal) {
+                    const minUnOptVal = range.from >= minOptimizationVal ? range.from : minOptimizationVal;
+                    const maxUnOptVal = range.to;
                     const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
                     const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
                     for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
@@ -39281,8 +39295,8 @@ function findCode(setNode, targetCharCodes) {
     if (typeof codeOrRange === "number") {
       return includes_default(targetCharCodes, codeOrRange);
     } else {
-      const range2 = codeOrRange;
-      return find_default(targetCharCodes, (targetCode) => range2.from <= targetCode && targetCode <= range2.to) !== void 0;
+      const range = codeOrRange;
+      return find_default(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== void 0;
     }
   });
 }
@@ -57187,8 +57201,8 @@ var require_createRange = __commonJS({
 var require_range = __commonJS({
   "node_modules/lodash/range.js"(exports2, module2) {
     var createRange = require_createRange();
-    var range2 = createRange();
-    module2.exports = range2;
+    var range = createRange();
+    module2.exports = range;
   }
 });
 
@@ -70110,6 +70124,15 @@ function normalizeJsonQuotes(str) {
   }
   return result;
 }
+function isCodeBlockEmbeddedInDocument(text, match2) {
+  const beforeBlock = text.substring(0, match2.index).trim();
+  const afterBlock = text.substring(match2.index + match2[0].length).trim();
+  const hasMarkdownHeadings = /^#{1,6}\s/m.test(beforeBlock) || /^#{1,6}\s/m.test(afterBlock);
+  if (hasMarkdownHeadings) {
+    return true;
+  }
+  return false;
+}
 function cleanSchemaResponse(response) {
   if (!response || typeof response !== "string") {
     return response;
@@ -70129,11 +70152,11 @@ function cleanSchemaResponse(response) {
     return cleanSchemaResponse(innerContent);
   }
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
-  if (jsonBlockMatch) {
+  if (jsonBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, jsonBlockMatch)) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
   }
   const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
-  if (anyBlockMatch) {
+  if (anyBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, anyBlockMatch)) {
     return normalizeJsonQuotes(anyBlockMatch[1].trim());
   }
   const codeBlockPatterns = [
@@ -70142,7 +70165,7 @@ function cleanSchemaResponse(response) {
   ];
   for (const pattern of codeBlockPatterns) {
     const match2 = trimmed.match(pattern);
-    if (match2) {
+    if (match2 && !isCodeBlockEmbeddedInDocument(trimmed, match2)) {
       return normalizeJsonQuotes(match2[1].trim());
     }
   }
@@ -70153,7 +70176,7 @@ function cleanSchemaResponse(response) {
   }
   const codeBlockStartPattern = /```(?:json)?\s*\n?\s*([{\[])/;
   const codeBlockMatch = trimmed.match(codeBlockStartPattern);
-  if (codeBlockMatch) {
+  if (codeBlockMatch && !isCodeBlockEmbeddedInDocument(trimmed, codeBlockMatch)) {
     const startIndex = codeBlockMatch.index + codeBlockMatch[0].length - 1;
     const openChar = codeBlockMatch[1];
     const closeChar = openChar === "{" ? "}" : "]";
@@ -77639,7 +77662,7 @@ var require_compose_scalar = __commonJS({
     var resolveBlockScalar = require_resolve_block_scalar();
     var resolveFlowScalar = require_resolve_flow_scalar();
     function composeScalar(ctx, token, tagToken, onError) {
-      const { value, type, comment, range: range2 } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+      const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
       const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
       let tag;
       if (ctx.options.stringKeys && ctx.atKey) {
@@ -77659,7 +77682,7 @@ var require_compose_scalar = __commonJS({
         onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
         scalar = new Scalar.Scalar(value);
       }
-      scalar.range = range2;
+      scalar.range = range;
       scalar.source = value;
       if (type)
         scalar.type = type;