@easynet/agent-tool-buildin 0.0.1

package/dist/index.cjs

@@ -0,0 +1,3840 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/jmespath/jmespath.js
+var require_jmespath = __commonJS({
+  "node_modules/jmespath/jmespath.js"(exports2) {
+    "use strict";
+    (function(exports3) {
+      "use strict";
+      function isArray2(obj) {
+        if (obj !== null) {
+          return Object.prototype.toString.call(obj) === "[object Array]";
+        } else {
+          return false;
+        }
+      }
+      function isObject(obj) {
+        if (obj !== null) {
+          return Object.prototype.toString.call(obj) === "[object Object]";
+        } else {
+          return false;
+        }
+      }
+      function strictDeepEqual(first, second) {
+        if (first === second) {
+          return true;
+        }
+        var firstType = Object.prototype.toString.call(first);
+        if (firstType !== Object.prototype.toString.call(second)) {
+          return false;
+        }
+        if (isArray2(first) === true) {
+          if (first.length !== second.length) {
+            return false;
+          }
+          for (var i = 0; i < first.length; i++) {
+            if (strictDeepEqual(first[i], second[i]) === false) {
+              return false;
+            }
+          }
+          return true;
+        }
+        if (isObject(first) === true) {
+          var keysSeen = {};
+          for (var key in first) {
+            if (hasOwnProperty.call(first, key)) {
+              if (strictDeepEqual(first[key], second[key]) === false) {
+                return false;
+              }
+              keysSeen[key] = true;
+            }
+          }
+          for (var key2 in second) {
+            if (hasOwnProperty.call(second, key2)) {
+              if (keysSeen[key2] !== true) {
+                return false;
+              }
+            }
+          }
+          return true;
+        }
+        return false;
+      }
+      function isFalse(obj) {
+        if (obj === "" || obj === false || obj === null) {
+          return true;
+        } else if (isArray2(obj) && obj.length === 0) {
+          return true;
+        } else if (isObject(obj)) {
+          for (var key in obj) {
+            if (obj.hasOwnProperty(key)) {
+              return false;
+            }
+          }
+          return true;
+        } else {
+          return false;
+        }
+      }
+      function objValues(obj) {
+        var keys = Object.keys(obj);
+        var values = [];
+        for (var i = 0; i < keys.length; i++) {
+          values.push(obj[keys[i]]);
+        }
+        return values;
+      }
+      function merge(a, b) {
+        var merged = {};
+        for (var key in a) {
+          merged[key] = a[key];
+        }
+        for (var key2 in b) {
+          merged[key2] = b[key2];
+        }
+        return merged;
+      }
+      var trimLeft;
+      if (typeof String.prototype.trimLeft === "function") {
+        trimLeft = function(str) {
+          return str.trimLeft();
+        };
+      } else {
+        trimLeft = function(str) {
+          return str.match(/^\s*(.*)/)[1];
+        };
+      }
+      var TYPE_NUMBER = 0;
+      var TYPE_ANY = 1;
+      var TYPE_STRING = 2;
+      var TYPE_ARRAY = 3;
+      var TYPE_OBJECT = 4;
+      var TYPE_BOOLEAN = 5;
+      var TYPE_EXPREF = 6;
+      var TYPE_NULL = 7;
+      var TYPE_ARRAY_NUMBER = 8;
+      var TYPE_ARRAY_STRING = 9;
+      var TYPE_NAME_TABLE = {
+        0: "number",
+        1: "any",
+        2: "string",
+        3: "array",
+        4: "object",
+        5: "boolean",
+        6: "expression",
+        7: "null",
+        8: "Array<number>",
+        9: "Array<string>"
+      };
+      var TOK_EOF = "EOF";
+      var TOK_UNQUOTEDIDENTIFIER = "UnquotedIdentifier";
+      var TOK_QUOTEDIDENTIFIER = "QuotedIdentifier";
+      var TOK_RBRACKET = "Rbracket";
+      var TOK_RPAREN = "Rparen";
+      var TOK_COMMA = "Comma";
+      var TOK_COLON = "Colon";
+      var TOK_RBRACE = "Rbrace";
+      var TOK_NUMBER = "Number";
+      var TOK_CURRENT = "Current";
+      var TOK_EXPREF = "Expref";
+      var TOK_PIPE = "Pipe";
+      var TOK_OR = "Or";
+      var TOK_AND = "And";
+      var TOK_EQ = "EQ";
+      var TOK_GT = "GT";
+      var TOK_LT = "LT";
+      var TOK_GTE = "GTE";
+      var TOK_LTE = "LTE";
+      var TOK_NE = "NE";
+      var TOK_FLATTEN = "Flatten";
+      var TOK_STAR = "Star";
+      var TOK_FILTER = "Filter";
+      var TOK_DOT = "Dot";
+      var TOK_NOT = "Not";
+      var TOK_LBRACE = "Lbrace";
+      var TOK_LBRACKET = "Lbracket";
+      var TOK_LPAREN = "Lparen";
+      var TOK_LITERAL = "Literal";
+      var basicTokens = {
+        ".": TOK_DOT,
+        "*": TOK_STAR,
+        ",": TOK_COMMA,
+        ":": TOK_COLON,
+        "{": TOK_LBRACE,
+        "}": TOK_RBRACE,
+        "]": TOK_RBRACKET,
+        "(": TOK_LPAREN,
+        ")": TOK_RPAREN,
+        "@": TOK_CURRENT
+      };
+      var operatorStartToken = {
+        "<": true,
+        ">": true,
+        "=": true,
+        "!": true
+      };
+      var skipChars = {
+        " ": true,
+        "	": true,
+        "\n": true
+      };
+      function isAlpha(ch) {
+        return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch === "_";
+      }
+      function isNum(ch) {
+        return ch >= "0" && ch <= "9" || ch === "-";
+      }
+      function isAlphaNum(ch) {
+        return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_";
+      }
+      function Lexer() {
+      }
+      Lexer.prototype = {
+        tokenize: function(stream) {
+          var tokens = [];
+          this._current = 0;
+          var start;
+          var identifier;
+          var token;
+          while (this._current < stream.length) {
+            if (isAlpha(stream[this._current])) {
+              start = this._current;
+              identifier = this._consumeUnquotedIdentifier(stream);
+              tokens.push({
+                type: TOK_UNQUOTEDIDENTIFIER,
+                value: identifier,
+                start
+              });
+            } else if (basicTokens[stream[this._current]] !== void 0) {
+              tokens.push({
+                type: basicTokens[stream[this._current]],
+                value: stream[this._current],
+                start: this._current
+              });
+              this._current++;
+            } else if (isNum(stream[this._current])) {
+              token = this._consumeNumber(stream);
+              tokens.push(token);
+            } else if (stream[this._current] === "[") {
+              token = this._consumeLBracket(stream);
+              tokens.push(token);
+            } else if (stream[this._current] === '"') {
+              start = this._current;
+              identifier = this._consumeQuotedIdentifier(stream);
+              tokens.push({
+                type: TOK_QUOTEDIDENTIFIER,
+                value: identifier,
+                start
+              });
+            } else if (stream[this._current] === "'") {
+              start = this._current;
+              identifier = this._consumeRawStringLiteral(stream);
+              tokens.push({
+                type: TOK_LITERAL,
+                value: identifier,
+                start
+              });
+            } else if (stream[this._current] === "`") {
+              start = this._current;
+              var literal = this._consumeLiteral(stream);
+              tokens.push({
+                type: TOK_LITERAL,
+                value: literal,
+                start
+              });
+            } else if (operatorStartToken[stream[this._current]] !== void 0) {
+              tokens.push(this._consumeOperator(stream));
+            } else if (skipChars[stream[this._current]] !== void 0) {
+              this._current++;
+            } else if (stream[this._current] === "&") {
+              start = this._current;
+              this._current++;
+              if (stream[this._current] === "&") {
+                this._current++;
+                tokens.push({ type: TOK_AND, value: "&&", start });
+              } else {
+                tokens.push({ type: TOK_EXPREF, value: "&", start });
+              }
+            } else if (stream[this._current] === "|") {
+              start = this._current;
+              this._current++;
+              if (stream[this._current] === "|") {
+                this._current++;
+                tokens.push({ type: TOK_OR, value: "||", start });
+              } else {
+                tokens.push({ type: TOK_PIPE, value: "|", start });
+              }
+            } else {
+              var error = new Error("Unknown character:" + stream[this._current]);
+              error.name = "LexerError";
+              throw error;
+            }
+          }
+          return tokens;
+        },
+        _consumeUnquotedIdentifier: function(stream) {
+          var start = this._current;
+          this._current++;
+          while (this._current < stream.length && isAlphaNum(stream[this._current])) {
+            this._current++;
+          }
+          return stream.slice(start, this._current);
+        },
+        _consumeQuotedIdentifier: function(stream) {
+          var start = this._current;
+          this._current++;
+          var maxLength = stream.length;
+          while (stream[this._current] !== '"' && this._current < maxLength) {
+            var current = this._current;
+            if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === '"')) {
+              current += 2;
+            } else {
+              current++;
+            }
+            this._current = current;
+          }
+          this._current++;
+          return JSON.parse(stream.slice(start, this._current));
+        },
+        _consumeRawStringLiteral: function(stream) {
+          var start = this._current;
+          this._current++;
+          var maxLength = stream.length;
+          while (stream[this._current] !== "'" && this._current < maxLength) {
+            var current = this._current;
+            if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "'")) {
+              current += 2;
+            } else {
+              current++;
+            }
+            this._current = current;
+          }
+          this._current++;
+          var literal = stream.slice(start + 1, this._current - 1);
+          return literal.replace("\\'", "'");
+        },
+        _consumeNumber: function(stream) {
+          var start = this._current;
+          this._current++;
+          var maxLength = stream.length;
+          while (isNum(stream[this._current]) && this._current < maxLength) {
+            this._current++;
+          }
+          var value = parseInt(stream.slice(start, this._current));
+          return { type: TOK_NUMBER, value, start };
+        },
+        _consumeLBracket: function(stream) {
+          var start = this._current;
+          this._current++;
+          if (stream[this._current] === "?") {
+            this._current++;
+            return { type: TOK_FILTER, value: "[?", start };
+          } else if (stream[this._current] === "]") {
+            this._current++;
+            return { type: TOK_FLATTEN, value: "[]", start };
+          } else {
+            return { type: TOK_LBRACKET, value: "[", start };
+          }
+        },
+        _consumeOperator: function(stream) {
+          var start = this._current;
+          var startingChar = stream[start];
+          this._current++;
+          if (startingChar === "!") {
+            if (stream[this._current] === "=") {
+              this._current++;
+              return { type: TOK_NE, value: "!=", start };
+            } else {
+              return { type: TOK_NOT, value: "!", start };
+            }
+          } else if (startingChar === "<") {
+            if (stream[this._current] === "=") {
+              this._current++;
+              return { type: TOK_LTE, value: "<=", start };
+            } else {
+              return { type: TOK_LT, value: "<", start };
+            }
+          } else if (startingChar === ">") {
+            if (stream[this._current] === "=") {
+              this._current++;
+              return { type: TOK_GTE, value: ">=", start };
+            } else {
+              return { type: TOK_GT, value: ">", start };
+            }
+          } else if (startingChar === "=") {
+            if (stream[this._current] === "=") {
+              this._current++;
+              return { type: TOK_EQ, value: "==", start };
+            }
+          }
+        },
+        _consumeLiteral: function(stream) {
+          this._current++;
+          var start = this._current;
+          var maxLength = stream.length;
+          var literal;
+          while (stream[this._current] !== "`" && this._current < maxLength) {
+            var current = this._current;
+            if (stream[current] === "\\" && (stream[current + 1] === "\\" || stream[current + 1] === "`")) {
+              current += 2;
+            } else {
+              current++;
+            }
+            this._current = current;
+          }
+          var literalString = trimLeft(stream.slice(start, this._current));
+          literalString = literalString.replace("\\`", "`");
+          if (this._looksLikeJSON(literalString)) {
+            literal = JSON.parse(literalString);
+          } else {
+            literal = JSON.parse('"' + literalString + '"');
+          }
+          this._current++;
+          return literal;
+        },
+        _looksLikeJSON: function(literalString) {
+          var startingChars = '[{"';
+          var jsonLiterals = ["true", "false", "null"];
+          var numberLooking = "-0123456789";
+          if (literalString === "") {
+            return false;
+          } else if (startingChars.indexOf(literalString[0]) >= 0) {
+            return true;
+          } else if (jsonLiterals.indexOf(literalString) >= 0) {
+            return true;
+          } else if (numberLooking.indexOf(literalString[0]) >= 0) {
+            try {
+              JSON.parse(literalString);
+              return true;
+            } catch (ex) {
+              return false;
+            }
+          } else {
+            return false;
+          }
+        }
+      };
+      var bindingPower = {};
+      bindingPower[TOK_EOF] = 0;
+      bindingPower[TOK_UNQUOTEDIDENTIFIER] = 0;
+      bindingPower[TOK_QUOTEDIDENTIFIER] = 0;
+      bindingPower[TOK_RBRACKET] = 0;
+      bindingPower[TOK_RPAREN] = 0;
+      bindingPower[TOK_COMMA] = 0;
+      bindingPower[TOK_RBRACE] = 0;
+      bindingPower[TOK_NUMBER] = 0;
+      bindingPower[TOK_CURRENT] = 0;
+      bindingPower[TOK_EXPREF] = 0;
+      bindingPower[TOK_PIPE] = 1;
+      bindingPower[TOK_OR] = 2;
+      bindingPower[TOK_AND] = 3;
+      bindingPower[TOK_EQ] = 5;
+      bindingPower[TOK_GT] = 5;
+      bindingPower[TOK_LT] = 5;
+      bindingPower[TOK_GTE] = 5;
+      bindingPower[TOK_LTE] = 5;
+      bindingPower[TOK_NE] = 5;
+      bindingPower[TOK_FLATTEN] = 9;
+      bindingPower[TOK_STAR] = 20;
+      bindingPower[TOK_FILTER] = 21;
+      bindingPower[TOK_DOT] = 40;
+      bindingPower[TOK_NOT] = 45;
+      bindingPower[TOK_LBRACE] = 50;
+      bindingPower[TOK_LBRACKET] = 55;
+      bindingPower[TOK_LPAREN] = 60;
+      function Parser() {
+      }
+      Parser.prototype = {
+        parse: function(expression) {
+          this._loadTokens(expression);
+          this.index = 0;
+          var ast = this.expression(0);
+          if (this._lookahead(0) !== TOK_EOF) {
+            var t = this._lookaheadToken(0);
+            var error = new Error(
+              "Unexpected token type: " + t.type + ", value: " + t.value
+            );
+            error.name = "ParserError";
+            throw error;
+          }
+          return ast;
+        },
+        _loadTokens: function(expression) {
+          var lexer = new Lexer();
+          var tokens = lexer.tokenize(expression);
+          tokens.push({ type: TOK_EOF, value: "", start: expression.length });
+          this.tokens = tokens;
+        },
+        expression: function(rbp) {
+          var leftToken = this._lookaheadToken(0);
+          this._advance();
+          var left = this.nud(leftToken);
+          var currentToken = this._lookahead(0);
+          while (rbp < bindingPower[currentToken]) {
+            this._advance();
+            left = this.led(currentToken, left);
+            currentToken = this._lookahead(0);
+          }
+          return left;
+        },
+        _lookahead: function(number) {
+          return this.tokens[this.index + number].type;
+        },
+        _lookaheadToken: function(number) {
+          return this.tokens[this.index + number];
+        },
+        _advance: function() {
+          this.index++;
+        },
+        nud: function(token) {
+          var left;
+          var right;
+          var expression;
+          switch (token.type) {
+            case TOK_LITERAL:
+              return { type: "Literal", value: token.value };
+            case TOK_UNQUOTEDIDENTIFIER:
+              return { type: "Field", name: token.value };
+            case TOK_QUOTEDIDENTIFIER:
+              var node = { type: "Field", name: token.value };
+              if (this._lookahead(0) === TOK_LPAREN) {
+                throw new Error("Quoted identifier not allowed for function names.");
+              }
+              return node;
+            case TOK_NOT:
+              right = this.expression(bindingPower.Not);
+              return { type: "NotExpression", children: [right] };
+            case TOK_STAR:
+              left = { type: "Identity" };
+              right = null;
+              if (this._lookahead(0) === TOK_RBRACKET) {
+                right = { type: "Identity" };
+              } else {
+                right = this._parseProjectionRHS(bindingPower.Star);
+              }
+              return { type: "ValueProjection", children: [left, right] };
+            case TOK_FILTER:
+              return this.led(token.type, { type: "Identity" });
+            case TOK_LBRACE:
+              return this._parseMultiselectHash();
+            case TOK_FLATTEN:
+              left = { type: TOK_FLATTEN, children: [{ type: "Identity" }] };
+              right = this._parseProjectionRHS(bindingPower.Flatten);
+              return { type: "Projection", children: [left, right] };
+            case TOK_LBRACKET:
+              if (this._lookahead(0) === TOK_NUMBER || this._lookahead(0) === TOK_COLON) {
+                right = this._parseIndexExpression();
+                return this._projectIfSlice({ type: "Identity" }, right);
+              } else if (this._lookahead(0) === TOK_STAR && this._lookahead(1) === TOK_RBRACKET) {
+                this._advance();
+                this._advance();
+                right = this._parseProjectionRHS(bindingPower.Star);
+                return {
+                  type: "Projection",
+                  children: [{ type: "Identity" }, right]
+                };
+              }
+              return this._parseMultiselectList();
+            case TOK_CURRENT:
+              return { type: TOK_CURRENT };
+            case TOK_EXPREF:
+              expression = this.expression(bindingPower.Expref);
+              return { type: "ExpressionReference", children: [expression] };
+            case TOK_LPAREN:
+              var args = [];
+              while (this._lookahead(0) !== TOK_RPAREN) {
+                if (this._lookahead(0) === TOK_CURRENT) {
+                  expression = { type: TOK_CURRENT };
+                  this._advance();
+                } else {
+                  expression = this.expression(0);
+                }
+                args.push(expression);
+              }
+              this._match(TOK_RPAREN);
+              return args[0];
+            default:
+              this._errorToken(token);
+          }
+        },
+        led: function(tokenName, left) {
+          var right;
+          switch (tokenName) {
+            case TOK_DOT:
+              var rbp = bindingPower.Dot;
+              if (this._lookahead(0) !== TOK_STAR) {
+                right = this._parseDotRHS(rbp);
+                return { type: "Subexpression", children: [left, right] };
+              }
+              this._advance();
+              right = this._parseProjectionRHS(rbp);
+              return { type: "ValueProjection", children: [left, right] };
+            case TOK_PIPE:
+              right = this.expression(bindingPower.Pipe);
+              return { type: TOK_PIPE, children: [left, right] };
+            case TOK_OR:
+              right = this.expression(bindingPower.Or);
+              return { type: "OrExpression", children: [left, right] };
+            case TOK_AND:
+              right = this.expression(bindingPower.And);
+              return { type: "AndExpression", children: [left, right] };
+            case TOK_LPAREN:
+              var name = left.name;
+              var args = [];
+              var expression, node;
+              while (this._lookahead(0) !== TOK_RPAREN) {
+                if (this._lookahead(0) === TOK_CURRENT) {
+                  expression = { type: TOK_CURRENT };
+                  this._advance();
+                } else {
+                  expression = this.expression(0);
+                }
+                if (this._lookahead(0) === TOK_COMMA) {
+                  this._match(TOK_COMMA);
+                }
+                args.push(expression);
+              }
+              this._match(TOK_RPAREN);
+              node = { type: "Function", name, children: args };
+              return node;
+            case TOK_FILTER:
+              var condition = this.expression(0);
+              this._match(TOK_RBRACKET);
+              if (this._lookahead(0) === TOK_FLATTEN) {
+                right = { type: "Identity" };
+              } else {
+                right = this._parseProjectionRHS(bindingPower.Filter);
+              }
+              return { type: "FilterProjection", children: [left, right, condition] };
+            case TOK_FLATTEN:
+              var leftNode = { type: TOK_FLATTEN, children: [left] };
+              var rightNode = this._parseProjectionRHS(bindingPower.Flatten);
+              return { type: "Projection", children: [leftNode, rightNode] };
+            case TOK_EQ:
+            case TOK_NE:
+            case TOK_GT:
+            case TOK_GTE:
+            case TOK_LT:
+            case TOK_LTE:
+              return this._parseComparator(left, tokenName);
+            case TOK_LBRACKET:
+              var token = this._lookaheadToken(0);
+              if (token.type === TOK_NUMBER || token.type === TOK_COLON) {
+                right = this._parseIndexExpression();
+                return this._projectIfSlice(left, right);
+              }
+              this._match(TOK_STAR);
+              this._match(TOK_RBRACKET);
+              right = this._parseProjectionRHS(bindingPower.Star);
+              return { type: "Projection", children: [left, right] };
+            default:
+              this._errorToken(this._lookaheadToken(0));
+          }
+        },
+        _match: function(tokenType) {
+          if (this._lookahead(0) === tokenType) {
+            this._advance();
+          } else {
+            var t = this._lookaheadToken(0);
+            var error = new Error("Expected " + tokenType + ", got: " + t.type);
+            error.name = "ParserError";
+            throw error;
+          }
+        },
+        _errorToken: function(token) {
+          var error = new Error("Invalid token (" + token.type + '): "' + token.value + '"');
+          error.name = "ParserError";
+          throw error;
+        },
+        _parseIndexExpression: function() {
+          if (this._lookahead(0) === TOK_COLON || this._lookahead(1) === TOK_COLON) {
+            return this._parseSliceExpression();
+          } else {
+            var node = {
+              type: "Index",
+              value: this._lookaheadToken(0).value
+            };
+            this._advance();
+            this._match(TOK_RBRACKET);
+            return node;
+          }
+        },
+        _projectIfSlice: function(left, right) {
+          var indexExpr = { type: "IndexExpression", children: [left, right] };
+          if (right.type === "Slice") {
+            return {
+              type: "Projection",
+              children: [indexExpr, this._parseProjectionRHS(bindingPower.Star)]
+            };
+          } else {
+            return indexExpr;
+          }
+        },
+        _parseSliceExpression: function() {
+          var parts = [null, null, null];
+          var index = 0;
+          var currentToken = this._lookahead(0);
+          while (currentToken !== TOK_RBRACKET && index < 3) {
+            if (currentToken === TOK_COLON) {
+              index++;
+              this._advance();
+            } else if (currentToken === TOK_NUMBER) {
+              parts[index] = this._lookaheadToken(0).value;
+              this._advance();
+            } else {
+              var t = this._lookahead(0);
+              var error = new Error("Syntax error, unexpected token: " + t.value + "(" + t.type + ")");
+              error.name = "Parsererror";
+              throw error;
+            }
+            currentToken = this._lookahead(0);
+          }
+          this._match(TOK_RBRACKET);
+          return {
+            type: "Slice",
+            children: parts
+          };
+        },
+        _parseComparator: function(left, comparator) {
+          var right = this.expression(bindingPower[comparator]);
+          return { type: "Comparator", name: comparator, children: [left, right] };
+        },
+        _parseDotRHS: function(rbp) {
+          var lookahead = this._lookahead(0);
+          var exprTokens = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER, TOK_STAR];
+          if (exprTokens.indexOf(lookahead) >= 0) {
+            return this.expression(rbp);
+          } else if (lookahead === TOK_LBRACKET) {
+            this._match(TOK_LBRACKET);
+            return this._parseMultiselectList();
+          } else if (lookahead === TOK_LBRACE) {
+            this._match(TOK_LBRACE);
+            return this._parseMultiselectHash();
+          }
+        },
+        _parseProjectionRHS: function(rbp) {
+          var right;
+          if (bindingPower[this._lookahead(0)] < 10) {
+            right = { type: "Identity" };
+          } else if (this._lookahead(0) === TOK_LBRACKET) {
+            right = this.expression(rbp);
+          } else if (this._lookahead(0) === TOK_FILTER) {
+            right = this.expression(rbp);
+          } else if (this._lookahead(0) === TOK_DOT) {
+            this._match(TOK_DOT);
+            right = this._parseDotRHS(rbp);
+          } else {
+            var t = this._lookaheadToken(0);
+            var error = new Error("Sytanx error, unexpected token: " + t.value + "(" + t.type + ")");
+            error.name = "ParserError";
+            throw error;
+          }
+          return right;
+        },
+        _parseMultiselectList: function() {
+          var expressions = [];
+          while (this._lookahead(0) !== TOK_RBRACKET) {
+            var expression = this.expression(0);
+            expressions.push(expression);
+            if (this._lookahead(0) === TOK_COMMA) {
+              this._match(TOK_COMMA);
+              if (this._lookahead(0) === TOK_RBRACKET) {
+                throw new Error("Unexpected token Rbracket");
+              }
+            }
+          }
+          this._match(TOK_RBRACKET);
+          return { type: "MultiSelectList", children: expressions };
+        },
+        _parseMultiselectHash: function() {
+          var pairs = [];
+          var identifierTypes = [TOK_UNQUOTEDIDENTIFIER, TOK_QUOTEDIDENTIFIER];
+          var keyToken, keyName, value, node;
+          for (; ; ) {
+            keyToken = this._lookaheadToken(0);
+            if (identifierTypes.indexOf(keyToken.type) < 0) {
+              throw new Error("Expecting an identifier token, got: " + keyToken.type);
+            }
+            keyName = keyToken.value;
+            this._advance();
+            this._match(TOK_COLON);
+            value = this.expression(0);
+            node = { type: "KeyValuePair", name: keyName, value };
+            pairs.push(node);
+            if (this._lookahead(0) === TOK_COMMA) {
+              this._match(TOK_COMMA);
+            } else if (this._lookahead(0) === TOK_RBRACE) {
+              this._match(TOK_RBRACE);
+              break;
+            }
+          }
+          return { type: "MultiSelectHash", children: pairs };
+        }
+      };
+      function TreeInterpreter(runtime) {
+        this.runtime = runtime;
+      }
+      TreeInterpreter.prototype = {
+        search: function(node, value) {
+          return this.visit(node, value);
+        },
+        visit: function(node, value) {
+          var matched, current, result, first, second, field, left, right, collected, i;
+          switch (node.type) {
+            case "Field":
+              if (value !== null && isObject(value)) {
+                field = value[node.name];
+                if (field === void 0) {
+                  return null;
+                } else {
+                  return field;
+                }
+              }
+              return null;
+            case "Subexpression":
+              result = this.visit(node.children[0], value);
+              for (i = 1; i < node.children.length; i++) {
+                result = this.visit(node.children[1], result);
+                if (result === null) {
+                  return null;
+                }
+              }
+              return result;
+            case "IndexExpression":
+              left = this.visit(node.children[0], value);
+              right = this.visit(node.children[1], left);
+              return right;
+            case "Index":
+              if (!isArray2(value)) {
+                return null;
+              }
+              var index = node.value;
+              if (index < 0) {
+                index = value.length + index;
+              }
+              result = value[index];
+              if (result === void 0) {
+                result = null;
+              }
+              return result;
+            case "Slice":
+              if (!isArray2(value)) {
+                return null;
+              }
+              var sliceParams = node.children.slice(0);
+              var computed = this.computeSliceParams(value.length, sliceParams);
+              var start = computed[0];
+              var stop = computed[1];
+              var step = computed[2];
+              result = [];
+              if (step > 0) {
+                for (i = start; i < stop; i += step) {
+                  result.push(value[i]);
+                }
+              } else {
+                for (i = start; i > stop; i += step) {
+                  result.push(value[i]);
+                }
+              }
+              return result;
+            case "Projection":
+              var base = this.visit(node.children[0], value);
+              if (!isArray2(base)) {
+                return null;
+              }
+              collected = [];
+              for (i = 0; i < base.length; i++) {
+                current = this.visit(node.children[1], base[i]);
+                if (current !== null) {
+                  collected.push(current);
+                }
+              }
+              return collected;
+            case "ValueProjection":
+              base = this.visit(node.children[0], value);
+              if (!isObject(base)) {
+                return null;
+              }
+              collected = [];
+              var values = objValues(base);
+              for (i = 0; i < values.length; i++) {
+                current = this.visit(node.children[1], values[i]);
+                if (current !== null) {
+                  collected.push(current);
+                }
+              }
+              return collected;
+            case "FilterProjection":
+              base = this.visit(node.children[0], value);
+              if (!isArray2(base)) {
+                return null;
+              }
+              var filtered = [];
+              var finalResults = [];
+              for (i = 0; i < base.length; i++) {
+                matched = this.visit(node.children[2], base[i]);
+                if (!isFalse(matched)) {
+                  filtered.push(base[i]);
+                }
+              }
+              for (var j = 0; j < filtered.length; j++) {
+                current = this.visit(node.children[1], filtered[j]);
+                if (current !== null) {
+                  finalResults.push(current);
+                }
+              }
+              return finalResults;
+            case "Comparator":
+              first = this.visit(node.children[0], value);
+              second = this.visit(node.children[1], value);
+              switch (node.name) {
+                case TOK_EQ:
+                  result = strictDeepEqual(first, second);
+                  break;
+                case TOK_NE:
+                  result = !strictDeepEqual(first, second);
+                  break;
+                case TOK_GT:
+                  result = first > second;
+                  break;
+                case TOK_GTE:
+                  result = first >= second;
+                  break;
+                case TOK_LT:
+                  result = first < second;
+                  break;
+                case TOK_LTE:
+                  result = first <= second;
+                  break;
+                default:
+                  throw new Error("Unknown comparator: " + node.name);
+              }
+              return result;
+            case TOK_FLATTEN:
+              var original = this.visit(node.children[0], value);
+              if (!isArray2(original)) {
+                return null;
+              }
+              var merged = [];
+              for (i = 0; i < original.length; i++) {
+                current = original[i];
+                if (isArray2(current)) {
+                  merged.push.apply(merged, current);
+                } else {
+                  merged.push(current);
+                }
+              }
+              return merged;
+            case "Identity":
+              return value;
+            case "MultiSelectList":
+              if (value === null) {
+                return null;
+              }
+              collected = [];
+              for (i = 0; i < node.children.length; i++) {
+                collected.push(this.visit(node.children[i], value));
+              }
+              return collected;
+            case "MultiSelectHash":
+              if (value === null) {
+                return null;
+              }
+              collected = {};
+              var child;
+              for (i = 0; i < node.children.length; i++) {
+                child = node.children[i];
+                collected[child.name] = this.visit(child.value, value);
+              }
+              return collected;
+            case "OrExpression":
+              matched = this.visit(node.children[0], value);
+              if (isFalse(matched)) {
+                matched = this.visit(node.children[1], value);
+              }
+              return matched;
+            case "AndExpression":
+              first = this.visit(node.children[0], value);
+              if (isFalse(first) === true) {
+                return first;
+              }
+              return this.visit(node.children[1], value);
+            case "NotExpression":
+              first = this.visit(node.children[0], value);
+              return isFalse(first);
+            case "Literal":
+              return node.value;
+            case TOK_PIPE:
+              left = this.visit(node.children[0], value);
+              return this.visit(node.children[1], left);
+            case TOK_CURRENT:
+              return value;
+            case "Function":
+              var resolvedArgs = [];
+              for (i = 0; i < node.children.length; i++) {
+                resolvedArgs.push(this.visit(node.children[i], value));
+              }
+              return this.runtime.callFunction(node.name, resolvedArgs);
+            case "ExpressionReference":
+              var refNode = node.children[0];
+              refNode.jmespathType = TOK_EXPREF;
+              return refNode;
+            default:
+              throw new Error("Unknown node type: " + node.type);
+          }
+        },
+        computeSliceParams: function(arrayLength, sliceParams) {
+          var start = sliceParams[0];
+          var stop = sliceParams[1];
+          var step = sliceParams[2];
+          var computed = [null, null, null];
+          if (step === null) {
+            step = 1;
+          } else if (step === 0) {
+            var error = new Error("Invalid slice, step cannot be 0");
+            error.name = "RuntimeError";
+            throw error;
+          }
+          var stepValueNegative = step < 0 ? true : false;
+          if (start === null) {
+            start = stepValueNegative ? arrayLength - 1 : 0;
+          } else {
+            start = this.capSliceRange(arrayLength, start, step);
+          }
+          if (stop === null) {
+            stop = stepValueNegative ? -1 : arrayLength;
+          } else {
+            stop = this.capSliceRange(arrayLength, stop, step);
+          }
+          computed[0] = start;
+          computed[1] = stop;
+          computed[2] = step;
+          return computed;
+        },
+        capSliceRange: function(arrayLength, actualValue, step) {
+          if (actualValue < 0) {
+            actualValue += arrayLength;
+            if (actualValue < 0) {
+              actualValue = step < 0 ? -1 : 0;
+            }
+          } else if (actualValue >= arrayLength) {
+            actualValue = step < 0 ? arrayLength - 1 : arrayLength;
+          }
+          return actualValue;
+        }
+      };
+      function Runtime(interpreter) {
+        this._interpreter = interpreter;
+        this.functionTable = {
+          // name: [function, <signature>]
+          // The <signature> can be:
+          //
+          // {
+          //   args: [[type1, type2], [type1, type2]],
+          //   variadic: true|false
+          // }
+          //
+          // Each arg in the arg list is a list of valid types
+          // (if the function is overloaded and supports multiple
+          // types.  If the type is "any" then no type checking
+          // occurs on the argument.  Variadic is optional
+          // and if not provided is assumed to be false.
+          abs: { _func: this._functionAbs, _signature: [{ types: [TYPE_NUMBER] }] },
+          avg: { _func: this._functionAvg, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+          ceil: { _func: this._functionCeil, _signature: [{ types: [TYPE_NUMBER] }] },
+          contains: {
+            _func: this._functionContains,
+            _signature: [
+              { types: [TYPE_STRING, TYPE_ARRAY] },
+              { types: [TYPE_ANY] }
+            ]
+          },
+          "ends_with": {
+            _func: this._functionEndsWith,
+            _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+          },
+          floor: { _func: this._functionFloor, _signature: [{ types: [TYPE_NUMBER] }] },
+          length: {
+            _func: this._functionLength,
+            _signature: [{ types: [TYPE_STRING, TYPE_ARRAY, TYPE_OBJECT] }]
+          },
+          map: {
+            _func: this._functionMap,
+            _signature: [{ types: [TYPE_EXPREF] }, { types: [TYPE_ARRAY] }]
+          },
+          max: {
+            _func: this._functionMax,
+            _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+          },
+          "merge": {
+            _func: this._functionMerge,
+            _signature: [{ types: [TYPE_OBJECT], variadic: true }]
+          },
+          "max_by": {
+            _func: this._functionMaxBy,
+            _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+          },
+          sum: { _func: this._functionSum, _signature: [{ types: [TYPE_ARRAY_NUMBER] }] },
+          "starts_with": {
+            _func: this._functionStartsWith,
+            _signature: [{ types: [TYPE_STRING] }, { types: [TYPE_STRING] }]
+          },
+          min: {
+            _func: this._functionMin,
+            _signature: [{ types: [TYPE_ARRAY_NUMBER, TYPE_ARRAY_STRING] }]
+          },
+          "min_by": {
+            _func: this._functionMinBy,
+            _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+          },
+          type: { _func: this._functionType, _signature: [{ types: [TYPE_ANY] }] },
+          keys: { _func: this._functionKeys, _signature: [{ types: [TYPE_OBJECT] }] },
+          values: { _func: this._functionValues, _signature: [{ types: [TYPE_OBJECT] }] },
+          sort: { _func: this._functionSort, _signature: [{ types: [TYPE_ARRAY_STRING, TYPE_ARRAY_NUMBER] }] },
+          "sort_by": {
+            _func: this._functionSortBy,
+            _signature: [{ types: [TYPE_ARRAY] }, { types: [TYPE_EXPREF] }]
+          },
+          join: {
+            _func: this._functionJoin,
+            _signature: [
+              { types: [TYPE_STRING] },
+              { types: [TYPE_ARRAY_STRING] }
+            ]
+          },
+          reverse: {
+            _func: this._functionReverse,
+            _signature: [{ types: [TYPE_STRING, TYPE_ARRAY] }]
+          },
+          "to_array": { _func: this._functionToArray, _signature: [{ types: [TYPE_ANY] }] },
+          "to_string": { _func: this._functionToString, _signature: [{ types: [TYPE_ANY] }] },
+          "to_number": { _func: this._functionToNumber, _signature: [{ types: [TYPE_ANY] }] },
+          "not_null": {
+            _func: this._functionNotNull,
+            _signature: [{ types: [TYPE_ANY], variadic: true }]
+          }
+        };
+      }
+      Runtime.prototype = {
+        callFunction: function(name, resolvedArgs) {
+          var functionEntry = this.functionTable[name];
+          if (functionEntry === void 0) {
+            throw new Error("Unknown function: " + name + "()");
+          }
+          this._validateArgs(name, resolvedArgs, functionEntry._signature);
+          return functionEntry._func.call(this, resolvedArgs);
+        },
+        _validateArgs: function(name, args, signature) {
+          var pluralized;
+          if (signature[signature.length - 1].variadic) {
+            if (args.length < signature.length) {
+              pluralized = signature.length === 1 ? " argument" : " arguments";
+              throw new Error("ArgumentError: " + name + "() takes at least" + signature.length + pluralized + " but received " + args.length);
+            }
+          } else if (args.length !== signature.length) {
+            pluralized = signature.length === 1 ? " argument" : " arguments";
+            throw new Error("ArgumentError: " + name + "() takes " + signature.length + pluralized + " but received " + args.length);
+          }
+          var currentSpec;
+          var actualType;
+          var typeMatched;
+          for (var i = 0; i < signature.length; i++) {
+            typeMatched = false;
+            currentSpec = signature[i].types;
+            actualType = this._getTypeName(args[i]);
+            for (var j = 0; j < currentSpec.length; j++) {
+              if (this._typeMatches(actualType, currentSpec[j], args[i])) {
+                typeMatched = true;
+                break;
+              }
+            }
+            if (!typeMatched) {
+              var expected = currentSpec.map(function(typeIdentifier) {
+                return TYPE_NAME_TABLE[typeIdentifier];
+              }).join(",");
+              throw new Error("TypeError: " + name + "() expected argument " + (i + 1) + " to be type " + expected + " but received type " + TYPE_NAME_TABLE[actualType] + " instead.");
+            }
+          }
+        },
+        _typeMatches: function(actual, expected, argValue) {
+          if (expected === TYPE_ANY) {
+            return true;
+          }
+          if (expected === TYPE_ARRAY_STRING || expected === TYPE_ARRAY_NUMBER || expected === TYPE_ARRAY) {
+            if (expected === TYPE_ARRAY) {
+              return actual === TYPE_ARRAY;
+            } else if (actual === TYPE_ARRAY) {
+              var subtype;
+              if (expected === TYPE_ARRAY_NUMBER) {
+                subtype = TYPE_NUMBER;
+              } else if (expected === TYPE_ARRAY_STRING) {
+                subtype = TYPE_STRING;
+              }
+              for (var i = 0; i < argValue.length; i++) {
+                if (!this._typeMatches(
+                  this._getTypeName(argValue[i]),
+                  subtype,
+                  argValue[i]
+                )) {
+                  return false;
+                }
+              }
+              return true;
+            }
+          } else {
+            return actual === expected;
+          }
+        },
+        _getTypeName: function(obj) {
+          switch (Object.prototype.toString.call(obj)) {
+            case "[object String]":
+              return TYPE_STRING;
+            case "[object Number]":
+              return TYPE_NUMBER;
+            case "[object Array]":
+              return TYPE_ARRAY;
+            case "[object Boolean]":
+              return TYPE_BOOLEAN;
+            case "[object Null]":
+              return TYPE_NULL;
+            case "[object Object]":
+              if (obj.jmespathType === TOK_EXPREF) {
+                return TYPE_EXPREF;
+              } else {
+                return TYPE_OBJECT;
+              }
+          }
+        },
+        _functionStartsWith: function(resolvedArgs) {
+          return resolvedArgs[0].lastIndexOf(resolvedArgs[1]) === 0;
+        },
+        _functionEndsWith: function(resolvedArgs) {
+          var searchStr = resolvedArgs[0];
+          var suffix = resolvedArgs[1];
+          return searchStr.indexOf(suffix, searchStr.length - suffix.length) !== -1;
+        },
+        _functionReverse: function(resolvedArgs) {
+          var typeName = this._getTypeName(resolvedArgs[0]);
+          if (typeName === TYPE_STRING) {
+            var originalStr = resolvedArgs[0];
+            var reversedStr = "";
+            for (var i = originalStr.length - 1; i >= 0; i--) {
+              reversedStr += originalStr[i];
+            }
+            return reversedStr;
+          } else {
+            var reversedArray = resolvedArgs[0].slice(0);
+            reversedArray.reverse();
+            return reversedArray;
+          }
+        },
+        _functionAbs: function(resolvedArgs) {
+          return Math.abs(resolvedArgs[0]);
+        },
+        _functionCeil: function(resolvedArgs) {
+          return Math.ceil(resolvedArgs[0]);
+        },
+        _functionAvg: function(resolvedArgs) {
+          var sum = 0;
+          var inputArray = resolvedArgs[0];
+          for (var i = 0; i < inputArray.length; i++) {
+            sum += inputArray[i];
+          }
+          return sum / inputArray.length;
+        },
+        _functionContains: function(resolvedArgs) {
+          return resolvedArgs[0].indexOf(resolvedArgs[1]) >= 0;
+        },
+        _functionFloor: function(resolvedArgs) {
+          return Math.floor(resolvedArgs[0]);
+        },
+        _functionLength: function(resolvedArgs) {
+          if (!isObject(resolvedArgs[0])) {
+            return resolvedArgs[0].length;
+          } else {
+            return Object.keys(resolvedArgs[0]).length;
+          }
+        },
+        _functionMap: function(resolvedArgs) {
+          var mapped = [];
+          var interpreter = this._interpreter;
+          var exprefNode = resolvedArgs[0];
+          var elements = resolvedArgs[1];
+          for (var i = 0; i < elements.length; i++) {
+            mapped.push(interpreter.visit(exprefNode, elements[i]));
+          }
+          return mapped;
+        },
+        _functionMerge: function(resolvedArgs) {
+          var merged = {};
+          for (var i = 0; i < resolvedArgs.length; i++) {
+            var current = resolvedArgs[i];
+            for (var key in current) {
+              merged[key] = current[key];
+            }
+          }
+          return merged;
+        },
+        _functionMax: function(resolvedArgs) {
+          if (resolvedArgs[0].length > 0) {
+            var typeName = this._getTypeName(resolvedArgs[0][0]);
+            if (typeName === TYPE_NUMBER) {
+              return Math.max.apply(Math, resolvedArgs[0]);
+            } else {
+              var elements = resolvedArgs[0];
+              var maxElement = elements[0];
+              for (var i = 1; i < elements.length; i++) {
+                if (maxElement.localeCompare(elements[i]) < 0) {
+                  maxElement = elements[i];
+                }
+              }
+              return maxElement;
+            }
+          } else {
+            return null;
+          }
+        },
+        _functionMin: function(resolvedArgs) {
+          if (resolvedArgs[0].length > 0) {
+            var typeName = this._getTypeName(resolvedArgs[0][0]);
+            if (typeName === TYPE_NUMBER) {
+              return Math.min.apply(Math, resolvedArgs[0]);
+            } else {
+              var elements = resolvedArgs[0];
+              var minElement = elements[0];
+              for (var i = 1; i < elements.length; i++) {
+                if (elements[i].localeCompare(minElement) < 0) {
+                  minElement = elements[i];
+                }
+              }
+              return minElement;
+            }
+          } else {
+            return null;
+          }
+        },
+        _functionSum: function(resolvedArgs) {
+          var sum = 0;
+          var listToSum = resolvedArgs[0];
+          for (var i = 0; i < listToSum.length; i++) {
+            sum += listToSum[i];
+          }
+          return sum;
+        },
+        _functionType: function(resolvedArgs) {
+          switch (this._getTypeName(resolvedArgs[0])) {
+            case TYPE_NUMBER:
+              return "number";
+            case TYPE_STRING:
+              return "string";
+            case TYPE_ARRAY:
+              return "array";
+            case TYPE_OBJECT:
+              return "object";
+            case TYPE_BOOLEAN:
+              return "boolean";
+            case TYPE_EXPREF:
+              return "expref";
+            case TYPE_NULL:
+              return "null";
+          }
+        },
+        _functionKeys: function(resolvedArgs) {
+          return Object.keys(resolvedArgs[0]);
+        },
+        _functionValues: function(resolvedArgs) {
+          var obj = resolvedArgs[0];
+          var keys = Object.keys(obj);
+          var values = [];
+          for (var i = 0; i < keys.length; i++) {
+            values.push(obj[keys[i]]);
+          }
+          return values;
+        },
+        _functionJoin: function(resolvedArgs) {
+          var joinChar = resolvedArgs[0];
+          var listJoin = resolvedArgs[1];
+          return listJoin.join(joinChar);
+        },
+        _functionToArray: function(resolvedArgs) {
+          if (this._getTypeName(resolvedArgs[0]) === TYPE_ARRAY) {
+            return resolvedArgs[0];
+          } else {
+            return [resolvedArgs[0]];
+          }
+        },
+        _functionToString: function(resolvedArgs) {
+          if (this._getTypeName(resolvedArgs[0]) === TYPE_STRING) {
+            return resolvedArgs[0];
+          } else {
+            return JSON.stringify(resolvedArgs[0]);
+          }
+        },
+        _functionToNumber: function(resolvedArgs) {
+          var typeName = this._getTypeName(resolvedArgs[0]);
+          var convertedValue;
+          if (typeName === TYPE_NUMBER) {
+            return resolvedArgs[0];
+          } else if (typeName === TYPE_STRING) {
+            convertedValue = +resolvedArgs[0];
+            if (!isNaN(convertedValue)) {
+              return convertedValue;
+            }
+          }
+          return null;
+        },
+        _functionNotNull: function(resolvedArgs) {
+          for (var i = 0; i < resolvedArgs.length; i++) {
+            if (this._getTypeName(resolvedArgs[i]) !== TYPE_NULL) {
+              return resolvedArgs[i];
+            }
+          }
+          return null;
+        },
+        _functionSort: function(resolvedArgs) {
+          var sortedArray = resolvedArgs[0].slice(0);
+          sortedArray.sort();
+          return sortedArray;
+        },
+        _functionSortBy: function(resolvedArgs) {
+          var sortedArray = resolvedArgs[0].slice(0);
+          if (sortedArray.length === 0) {
+            return sortedArray;
+          }
+          var interpreter = this._interpreter;
+          var exprefNode = resolvedArgs[1];
+          var requiredType = this._getTypeName(
+            interpreter.visit(exprefNode, sortedArray[0])
+          );
+          if ([TYPE_NUMBER, TYPE_STRING].indexOf(requiredType) < 0) {
+            throw new Error("TypeError");
+          }
+          var that = this;
+          var decorated = [];
+          for (var i = 0; i < sortedArray.length; i++) {
+            decorated.push([i, sortedArray[i]]);
+          }
+          decorated.sort(function(a, b) {
+            var exprA = interpreter.visit(exprefNode, a[1]);
+            var exprB = interpreter.visit(exprefNode, b[1]);
+            if (that._getTypeName(exprA) !== requiredType) {
+              throw new Error(
+                "TypeError: expected " + requiredType + ", received " + that._getTypeName(exprA)
+              );
+            } else if (that._getTypeName(exprB) !== requiredType) {
+              throw new Error(
+                "TypeError: expected " + requiredType + ", received " + that._getTypeName(exprB)
+              );
+            }
+            if (exprA > exprB) {
+              return 1;
+            } else if (exprA < exprB) {
+              return -1;
+            } else {
+              return a[0] - b[0];
+            }
+          });
+          for (var j = 0; j < decorated.length; j++) {
+            sortedArray[j] = decorated[j][1];
+          }
+          return sortedArray;
+        },
+        _functionMaxBy: function(resolvedArgs) {
+          var exprefNode = resolvedArgs[1];
+          var resolvedArray = resolvedArgs[0];
+          var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+          var maxNumber = -Infinity;
+          var maxRecord;
+          var current;
+          for (var i = 0; i < resolvedArray.length; i++) {
+            current = keyFunction(resolvedArray[i]);
+            if (current > maxNumber) {
+              maxNumber = current;
+              maxRecord = resolvedArray[i];
+            }
+          }
+          return maxRecord;
+        },
+        _functionMinBy: function(resolvedArgs) {
+          var exprefNode = resolvedArgs[1];
+          var resolvedArray = resolvedArgs[0];
+          var keyFunction = this.createKeyFunction(exprefNode, [TYPE_NUMBER, TYPE_STRING]);
+          var minNumber = Infinity;
+          var minRecord;
+          var current;
+          for (var i = 0; i < resolvedArray.length; i++) {
+            current = keyFunction(resolvedArray[i]);
+            if (current < minNumber) {
+              minNumber = current;
+              minRecord = resolvedArray[i];
+            }
+          }
+          return minRecord;
+        },
+        createKeyFunction: function(exprefNode, allowedTypes) {
+          var that = this;
+          var interpreter = this._interpreter;
+          var keyFunc = function(x) {
+            var current = interpreter.visit(exprefNode, x);
+            if (allowedTypes.indexOf(that._getTypeName(current)) < 0) {
+              var msg = "TypeError: expected one of " + allowedTypes + ", received " + that._getTypeName(current);
+              throw new Error(msg);
+            }
+            return current;
+          };
+          return keyFunc;
+        }
+      };
+      function compile(stream) {
+        var parser = new Parser();
+        var ast = parser.parse(stream);
+        return ast;
+      }
+      function tokenize(stream) {
+        var lexer = new Lexer();
+        return lexer.tokenize(stream);
+      }
+      function search(data, expression) {
+        var parser = new Parser();
+        var runtime = new Runtime();
+        var interpreter = new TreeInterpreter(runtime);
+        runtime._interpreter = interpreter;
+        var node = parser.parse(expression);
+        return interpreter.search(node, data);
+      }
+      exports3.tokenize = tokenize;
+      exports3.compile = compile;
+      exports3.search = search;
+      exports3.strictDeepEqual = strictDeepEqual;
+    })(typeof exports2 === "undefined" ? exports2.jmespath = {} : exports2);
+  }
+});
+
+// node_modules/mustache/mustache.mjs
+var mustache_exports = {};
+__export(mustache_exports, {
+  default: () => mustache_default
+});
+function isFunction(object) {
+  return typeof object === "function";
+}
+function typeStr(obj) {
+  return isArray(obj) ? "array" : typeof obj;
+}
+function escapeRegExp2(string) {
+  return string.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&");
+}
+function hasProperty(obj, propName) {
+  return obj != null && typeof obj === "object" && propName in obj;
+}
+function primitiveHasOwnProperty(primitive, propName) {
+  return primitive != null && typeof primitive !== "object" && primitive.hasOwnProperty && primitive.hasOwnProperty(propName);
+}
+function testRegExp(re, string) {
+  return regExpTest.call(re, string);
+}
+function isWhitespace(string) {
+  return !testRegExp(nonSpaceRe, string);
+}
+function escapeHtml(string) {
+  return String(string).replace(/[&<>"'`=\/]/g, function fromEntityMap(s) {
+    return entityMap[s];
+  });
+}
+function parseTemplate(template, tags) {
+  if (!template)
+    return [];
+  var lineHasNonSpace = false;
+  var sections = [];
+  var tokens = [];
+  var spaces = [];
+  var hasTag = false;
+  var nonSpace = false;
+  var indentation = "";
+  var tagIndex = 0;
+  function stripSpace() {
+    if (hasTag && !nonSpace) {
+      while (spaces.length)
+        delete tokens[spaces.pop()];
+    } else {
+      spaces = [];
+    }
+    hasTag = false;
+    nonSpace = false;
+  }
+  var openingTagRe, closingTagRe, closingCurlyRe;
+  function compileTags(tagsToCompile) {
+    if (typeof tagsToCompile === "string")
+      tagsToCompile = tagsToCompile.split(spaceRe, 2);
+    if (!isArray(tagsToCompile) || tagsToCompile.length !== 2)
+      throw new Error("Invalid tags: " + tagsToCompile);
+    openingTagRe = new RegExp(escapeRegExp2(tagsToCompile[0]) + "\\s*");
+    closingTagRe = new RegExp("\\s*" + escapeRegExp2(tagsToCompile[1]));
+    closingCurlyRe = new RegExp("\\s*" + escapeRegExp2("}" + tagsToCompile[1]));
+  }
+  compileTags(tags || mustache.tags);
+  var scanner = new Scanner(template);
+  var start, type, value, chr, token, openSection;
+  while (!scanner.eos()) {
+    start = scanner.pos;
+    value = scanner.scanUntil(openingTagRe);
+    if (value) {
+      for (var i = 0, valueLength = value.length; i < valueLength; ++i) {
+        chr = value.charAt(i);
+        if (isWhitespace(chr)) {
+          spaces.push(tokens.length);
+          indentation += chr;
+        } else {
+          nonSpace = true;
+          lineHasNonSpace = true;
+          indentation += " ";
+        }
+        tokens.push(["text", chr, start, start + 1]);
+        start += 1;
+        if (chr === "\n") {
+          stripSpace();
+          indentation = "";
+          tagIndex = 0;
+          lineHasNonSpace = false;
+        }
+      }
+    }
+    if (!scanner.scan(openingTagRe))
+      break;
+    hasTag = true;
+    type = scanner.scan(tagRe) || "name";
+    scanner.scan(whiteRe);
+    if (type === "=") {
+      value = scanner.scanUntil(equalsRe);
+      scanner.scan(equalsRe);
+      scanner.scanUntil(closingTagRe);
+    } else if (type === "{") {
+      value = scanner.scanUntil(closingCurlyRe);
+      scanner.scan(curlyRe);
+      scanner.scanUntil(closingTagRe);
+      type = "&";
+    } else {
+      value = scanner.scanUntil(closingTagRe);
+    }
+    if (!scanner.scan(closingTagRe))
+      throw new Error("Unclosed tag at " + scanner.pos);
+    if (type == ">") {
+      token = [type, value, start, scanner.pos, indentation, tagIndex, lineHasNonSpace];
+    } else {
+      token = [type, value, start, scanner.pos];
+    }
+    tagIndex++;
+    tokens.push(token);
+    if (type === "#" || type === "^") {
+      sections.push(token);
+    } else if (type === "/") {
+      openSection = sections.pop();
+      if (!openSection)
+        throw new Error('Unopened section "' + value + '" at ' + start);
+      if (openSection[1] !== value)
+        throw new Error('Unclosed section "' + openSection[1] + '" at ' + start);
+    } else if (type === "name" || type === "{" || type === "&") {
+      nonSpace = true;
+    } else if (type === "=") {
+      compileTags(value);
+    }
+  }
+  stripSpace();
+  openSection = sections.pop();
+  if (openSection)
+    throw new Error('Unclosed section "' + openSection[1] + '" at ' + scanner.pos);
+  return nestTokens(squashTokens(tokens));
+}
+function squashTokens(tokens) {
+  var squashedTokens = [];
+  var token, lastToken;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    token = tokens[i];
+    if (token) {
+      if (token[0] === "text" && lastToken && lastToken[0] === "text") {
+        lastToken[1] += token[1];
+        lastToken[3] = token[3];
+      } else {
+        squashedTokens.push(token);
+        lastToken = token;
+      }
+    }
+  }
+  return squashedTokens;
+}
+function nestTokens(tokens) {
+  var nestedTokens = [];
+  var collector = nestedTokens;
+  var sections = [];
+  var token, section;
+  for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+    token = tokens[i];
+    switch (token[0]) {
+      case "#":
+      case "^":
+        collector.push(token);
+        sections.push(token);
+        collector = token[4] = [];
+        break;
+      case "/":
+        section = sections.pop();
+        section[5] = token[2];
+        collector = sections.length > 0 ? sections[sections.length - 1][4] : nestedTokens;
+        break;
+      default:
+        collector.push(token);
+    }
+  }
+  return nestedTokens;
+}
+function Scanner(string) {
+  this.string = string;
+  this.tail = string;
+  this.pos = 0;
+}
+function Context(view, parentContext) {
+  this.view = view;
+  this.cache = { ".": this.view };
+  this.parent = parentContext;
+}
+function Writer() {
+  this.templateCache = {
+    _cache: {},
+    set: function set(key, value) {
+      this._cache[key] = value;
+    },
+    get: function get(key) {
+      return this._cache[key];
+    },
+    clear: function clear() {
+      this._cache = {};
+    }
+  };
+}
+var objectToString, isArray, regExpTest, nonSpaceRe, entityMap, whiteRe, spaceRe, equalsRe, curlyRe, tagRe, mustache, defaultWriter, mustache_default;
+var init_mustache = __esm({
+  "node_modules/mustache/mustache.mjs"() {
+    "use strict";
+    objectToString = Object.prototype.toString;
+    isArray = Array.isArray || function isArrayPolyfill(object) {
+      return objectToString.call(object) === "[object Array]";
+    };
+    regExpTest = RegExp.prototype.test;
+    nonSpaceRe = /\S/;
+    entityMap = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;",
+      "/": "&#x2F;",
+      "`": "&#x60;",
+      "=": "&#x3D;"
+    };
+    whiteRe = /\s*/;
+    spaceRe = /\s+/;
+    equalsRe = /\s*=/;
+    curlyRe = /\s*\}/;
+    tagRe = /#|\^|\/|>|\{|&|=|!/;
+    Scanner.prototype.eos = function eos() {
+      return this.tail === "";
+    };
+    Scanner.prototype.scan = function scan(re) {
+      var match = this.tail.match(re);
+      if (!match || match.index !== 0)
+        return "";
+      var string = match[0];
+      this.tail = this.tail.substring(string.length);
+      this.pos += string.length;
+      return string;
+    };
+    Scanner.prototype.scanUntil = function scanUntil(re) {
+      var index = this.tail.search(re), match;
+      switch (index) {
+        case -1:
+          match = this.tail;
+          this.tail = "";
+          break;
+        case 0:
+          match = "";
+          break;
+        default:
+          match = this.tail.substring(0, index);
+          this.tail = this.tail.substring(index);
+      }
+      this.pos += match.length;
+      return match;
+    };
+    Context.prototype.push = function push(view) {
+      return new Context(view, this);
+    };
+    Context.prototype.lookup = function lookup2(name) {
+      var cache = this.cache;
+      var value;
+      if (cache.hasOwnProperty(name)) {
+        value = cache[name];
+      } else {
+        var context = this, intermediateValue, names, index, lookupHit = false;
+        while (context) {
+          if (name.indexOf(".") > 0) {
+            intermediateValue = context.view;
+            names = name.split(".");
+            index = 0;
+            while (intermediateValue != null && index < names.length) {
+              if (index === names.length - 1)
+                lookupHit = hasProperty(intermediateValue, names[index]) || primitiveHasOwnProperty(intermediateValue, names[index]);
+              intermediateValue = intermediateValue[names[index++]];
+            }
+          } else {
+            intermediateValue = context.view[name];
+            lookupHit = hasProperty(context.view, name);
+          }
+          if (lookupHit) {
+            value = intermediateValue;
+            break;
+          }
+          context = context.parent;
+        }
+        cache[name] = value;
+      }
+      if (isFunction(value))
+        value = value.call(this.view);
+      return value;
+    };
+    Writer.prototype.clearCache = function clearCache() {
+      if (typeof this.templateCache !== "undefined") {
+        this.templateCache.clear();
+      }
+    };
+    Writer.prototype.parse = function parse2(template, tags) {
+      var cache = this.templateCache;
+      var cacheKey = template + ":" + (tags || mustache.tags).join(":");
+      var isCacheEnabled = typeof cache !== "undefined";
+      var tokens = isCacheEnabled ? cache.get(cacheKey) : void 0;
+      if (tokens == void 0) {
+        tokens = parseTemplate(template, tags);
+        isCacheEnabled && cache.set(cacheKey, tokens);
+      }
+      return tokens;
+    };
+    Writer.prototype.render = function render(template, view, partials, config) {
+      var tags = this.getConfigTags(config);
+      var tokens = this.parse(template, tags);
+      var context = view instanceof Context ? view : new Context(view, void 0);
+      return this.renderTokens(tokens, context, partials, template, config);
+    };
+    Writer.prototype.renderTokens = function renderTokens(tokens, context, partials, originalTemplate, config) {
+      var buffer = "";
+      var token, symbol, value;
+      for (var i = 0, numTokens = tokens.length; i < numTokens; ++i) {
+        value = void 0;
+        token = tokens[i];
+        symbol = token[0];
+        if (symbol === "#") value = this.renderSection(token, context, partials, originalTemplate, config);
+        else if (symbol === "^") value = this.renderInverted(token, context, partials, originalTemplate, config);
+        else if (symbol === ">") value = this.renderPartial(token, context, partials, config);
+        else if (symbol === "&") value = this.unescapedValue(token, context);
+        else if (symbol === "name") value = this.escapedValue(token, context, config);
+        else if (symbol === "text") value = this.rawValue(token);
+        if (value !== void 0)
+          buffer += value;
+      }
+      return buffer;
+    };
+    Writer.prototype.renderSection = function renderSection(token, context, partials, originalTemplate, config) {
+      var self = this;
+      var buffer = "";
+      var value = context.lookup(token[1]);
+      function subRender(template) {
+        return self.render(template, context, partials, config);
+      }
+      if (!value) return;
+      if (isArray(value)) {
+        for (var j = 0, valueLength = value.length; j < valueLength; ++j) {
+          buffer += this.renderTokens(token[4], context.push(value[j]), partials, originalTemplate, config);
+        }
+      } else if (typeof value === "object" || typeof value === "string" || typeof value === "number") {
+        buffer += this.renderTokens(token[4], context.push(value), partials, originalTemplate, config);
+      } else if (isFunction(value)) {
+        if (typeof originalTemplate !== "string")
+          throw new Error("Cannot use higher-order sections without the original template");
+        value = value.call(context.view, originalTemplate.slice(token[3], token[5]), subRender);
+        if (value != null)
+          buffer += value;
+      } else {
+        buffer += this.renderTokens(token[4], context, partials, originalTemplate, config);
+      }
+      return buffer;
+    };
+    Writer.prototype.renderInverted = function renderInverted(token, context, partials, originalTemplate, config) {
+      var value = context.lookup(token[1]);
+      if (!value || isArray(value) && value.length === 0)
+        return this.renderTokens(token[4], context, partials, originalTemplate, config);
+    };
+    Writer.prototype.indentPartial = function indentPartial(partial, indentation, lineHasNonSpace) {
+      var filteredIndentation = indentation.replace(/[^ \t]/g, "");
+      var partialByNl = partial.split("\n");
+      for (var i = 0; i < partialByNl.length; i++) {
+        if (partialByNl[i].length && (i > 0 || !lineHasNonSpace)) {
+          partialByNl[i] = filteredIndentation + partialByNl[i];
+        }
+      }
+      return partialByNl.join("\n");
+    };
+    Writer.prototype.renderPartial = function renderPartial(token, context, partials, config) {
+      if (!partials) return;
+      var tags = this.getConfigTags(config);
+      var value = isFunction(partials) ? partials(token[1]) : partials[token[1]];
+      if (value != null) {
+        var lineHasNonSpace = token[6];
+        var tagIndex = token[5];
+        var indentation = token[4];
+        var indentedValue = value;
+        if (tagIndex == 0 && indentation) {
+          indentedValue = this.indentPartial(value, indentation, lineHasNonSpace);
+        }
+        var tokens = this.parse(indentedValue, tags);
+        return this.renderTokens(tokens, context, partials, indentedValue, config);
+      }
+    };
+    Writer.prototype.unescapedValue = function unescapedValue(token, context) {
+      var value = context.lookup(token[1]);
+      if (value != null)
+        return value;
+    };
+    Writer.prototype.escapedValue = function escapedValue(token, context, config) {
+      var escape = this.getConfigEscape(config) || mustache.escape;
+      var value = context.lookup(token[1]);
+      if (value != null)
+        return typeof value === "number" && escape === mustache.escape ? String(value) : escape(value);
+    };
+    Writer.prototype.rawValue = function rawValue(token) {
+      return token[1];
+    };
+    Writer.prototype.getConfigTags = function getConfigTags(config) {
+      if (isArray(config)) {
+        return config;
+      } else if (config && typeof config === "object") {
+        return config.tags;
+      } else {
+        return void 0;
+      }
+    };
+    Writer.prototype.getConfigEscape = function getConfigEscape(config) {
+      if (config && typeof config === "object" && !isArray(config)) {
+        return config.escape;
+      } else {
+        return void 0;
+      }
+    };
+    mustache = {
+      name: "mustache.js",
+      version: "4.2.0",
+      tags: ["{{", "}}"],
+      clearCache: void 0,
+      escape: void 0,
+      parse: void 0,
+      render: void 0,
+      Scanner: void 0,
+      Context: void 0,
+      Writer: void 0,
+      /**
+       * Allows a user to override the default caching strategy, by providing an
+       * object with set, get and clear methods. This can also be used to disable
+       * the cache by setting it to the literal `undefined`.
+       */
+      set templateCache(cache) {
+        defaultWriter.templateCache = cache;
+      },
+      /**
+       * Gets the default or overridden caching object from the default writer.
+       */
+      get templateCache() {
+        return defaultWriter.templateCache;
+      }
+    };
+    defaultWriter = new Writer();
+    mustache.clearCache = function clearCache2() {
+      return defaultWriter.clearCache();
+    };
+    mustache.parse = function parse3(template, tags) {
+      return defaultWriter.parse(template, tags);
+    };
+    mustache.render = function render2(template, view, partials, config) {
+      if (typeof template !== "string") {
+        throw new TypeError('Invalid template! Template should be a "string" but "' + typeStr(template) + '" was given as the first argument for mustache#render(template, view, partials)');
+      }
+      return defaultWriter.render(template, view, partials, config);
+    };
+    mustache.escape = escapeHtml;
+    mustache.Scanner = Scanner;
+    mustache.Context = Context;
+    mustache.Writer = Writer;
+    mustache_default = mustache;
+  }
+});
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  CoreAdapter: () => CoreAdapter,
+  DEFAULT_CORE_TOOLS_CONFIG: () => DEFAULT_CORE_TOOLS_CONFIG,
+  deletePathSpec: () => deletePathSpec,
+  downloadFileSpec: () => downloadFileSpec,
+  duckduckgoSearchSpec: () => duckduckgoSearchSpec,
+  fetchJsonSpec: () => fetchJsonSpec,
+  fetchPageMainContentSpec: () => fetchPageMainContentSpec,
+  fetchTextSpec: () => fetchTextSpec,
+  getBuiltinContext: () => getBuiltinContext,
+  hashTextSpec: () => hashTextSpec,
+  headSpec: () => headSpec,
+  isIpInBlockedCidrs: () => isIpInBlockedCidrs,
+  jsonSelectSpec: () => jsonSelectSpec,
+  listDirSpec: () => listDirSpec,
+  nowHandler: () => nowHandler,
+  nowSpec: () => nowSpec,
+  readTextSpec: () => readTextSpec,
+  registerCoreTools: () => registerCoreTools,
+  resolveSandboxedPath: () => resolveSandboxedPath,
+  runCommandSpec: () => runCommandSpec,
+  runWithBuiltinContext: () => runWithBuiltinContext,
+  searchTextSpec: () => searchTextSpec,
+  sha256Spec: () => sha256Spec,
+  templateRenderSpec: () => templateRenderSpec,
+  truncateSpec: () => truncateSpec,
+  validateUrl: () => validateUrl,
+  writeTextSpec: () => writeTextSpec
+});
+module.exports = __toCommonJS(index_exports);
+
+// context.ts
+var import_node_async_hooks = require("async_hooks");
+var storage = new import_node_async_hooks.AsyncLocalStorage();
+function getBuiltinContext() {
+  const ctx = storage.getStore();
+  if (!ctx) throw new Error("Builtin context not set; invoke only through CoreAdapter.");
+  return ctx;
+}
+function runWithBuiltinContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+
+// CoreAdapter.ts
+var CoreAdapter = class {
+  kind = "core";
+  handlers = /* @__PURE__ */ new Map();
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Register a handler for a specific core tool name.
+   */
+  registerHandler(toolName, handler) {
+    this.handlers.set(toolName, handler);
+  }
+  /**
+   * Unregister a handler.
+   */
+  unregisterHandler(toolName) {
+    return this.handlers.delete(toolName);
+  }
+  /**
+   * List registered core tool names.
+   */
+  getRegisteredTools() {
+    return Array.from(this.handlers.keys());
+  }
+  /**
+   * Invoke dispatches to the appropriate handler by spec.name.
+   */
+  async invoke(spec, args, ctx) {
+    const handler = this.handlers.get(spec.name);
+    if (!handler) {
+      throw new Error(
+        `Core tool handler not found: ${spec.name}. Available: [${this.getRegisteredTools().join(", ")}]`
+      );
+    }
+    const coreCtx = {
+      execCtx: ctx,
+      config: this.config
+    };
+    const output = await runWithBuiltinContext(
+      coreCtx,
+      () => handler(args)
+    );
+    return {
+      result: output.result,
+      raw: { evidence: output.evidence }
+    };
+  }
+};
+
+// CoreToolsModule.ts
+var import_core = require("@easynet/agent-tool/core");
+
+// types.ts
+var DEFAULT_CORE_TOOLS_CONFIG = {
+  maxReadBytes: 5 * 1024 * 1024,
+  maxHttpBytes: 5 * 1024 * 1024,
+  maxDownloadBytes: 100 * 1024 * 1024,
+  blockedCidrs: [
+    "127.0.0.0/8",
+    "10.0.0.0/8",
+    "172.16.0.0/12",
+    "192.168.0.0/16",
+    "169.254.0.0/16",
+    "::1/128",
+    "fc00::/7",
+    "fe80::/10"
+  ],
+  defaultTimeoutMs: 15e3,
+  httpUserAgent: "agent-tool-core/1.0",
+  enableAutoWriteLargeResponses: false,
+  allowedCommands: [
+    "cat",
+    "echo",
+    "env",
+    "find",
+    "grep",
+    "head",
+    "ls",
+    "pwd",
+    "tail",
+    "wc",
+    "whoami"
+  ],
+  maxCommandOutputBytes: 1024 * 1024,
+  commandTimeoutMs: 1e4
+};
+
+// fs/readText.ts
+var import_promises2 = require("fs/promises");
+
+// security/sandbox.ts
+var import_node_path = require("path");
+var import_promises = require("fs/promises");
+var import_agent_tool = require("@easynet/agent-tool");
+async function resolveSandboxedPath(inputPath, sandboxRoot) {
+  let normalizedRoot;
+  try {
+    normalizedRoot = await (0, import_promises.realpath)((0, import_node_path.resolve)(sandboxRoot));
+  } catch {
+    normalizedRoot = (0, import_node_path.normalize)((0, import_node_path.resolve)(sandboxRoot));
+  }
+  const resolved = (0, import_node_path.resolve)(normalizedRoot, inputPath);
+  let real;
+  try {
+    await (0, import_promises.access)(resolved);
+    real = await (0, import_promises.realpath)(resolved);
+  } catch {
+    const parentDir = (0, import_node_path.dirname)(resolved);
+    let realParent;
+    try {
+      await (0, import_promises.access)(parentDir);
+      realParent = await (0, import_promises.realpath)(parentDir);
+    } catch {
+      realParent = (0, import_node_path.normalize)(parentDir);
+    }
+    real = (0, import_node_path.resolve)(realParent, (0, import_node_path.basename)(resolved));
+  }
+  if (!isWithinRoot(real, normalizedRoot)) {
+    throw (0, import_agent_tool.createTaggedError)(
+      "PATH_OUTSIDE_SANDBOX",
+      `Path "${inputPath}" resolves to "${real}" which is outside sandbox "${normalizedRoot}"`,
+      { inputPath, resolvedPath: real, sandboxRoot: normalizedRoot }
+    );
+  }
+  return real;
+}
+function isWithinRoot(path, root) {
+  const normalizedPath = (0, import_node_path.normalize)(path);
+  const normalizedRoot = (0, import_node_path.normalize)(root);
+  return normalizedPath === normalizedRoot || normalizedPath.startsWith(normalizedRoot + "/");
+}
+
+// fs/readText.ts
+var import_agent_tool2 = require("@easynet/agent-tool");
+var readTextHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const inputPath = args.path;
+  const maxBytes = args.maxBytes ?? ctx.config.maxReadBytes;
+  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const fileStat = await (0, import_promises2.stat)(resolvedPath);
+  if (fileStat.size > maxBytes) {
+    throw (0, import_agent_tool2.createTaggedError)(
+      "FILE_TOO_LARGE",
+      `File size ${fileStat.size} bytes exceeds limit of ${maxBytes} bytes`,
+      { path: resolvedPath, size: fileStat.size, limit: maxBytes }
+    );
+  }
+  const text = await (0, import_promises2.readFile)(resolvedPath, "utf-8");
+  return {
+    result: {
+      path: resolvedPath,
+      text,
+      bytes: fileStat.size
+    },
+    evidence: [
+      {
+        type: "file",
+        ref: resolvedPath,
+        summary: `Read ${fileStat.size} bytes from ${resolvedPath}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// fs/writeText.ts
+var import_promises3 = require("fs/promises");
+var import_node_crypto = require("crypto");
+var import_node_path2 = require("path");
+var writeTextHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const inputPath = args.path;
+  const text = args.text;
+  const overwrite = args.overwrite ?? false;
+  const mkdirp = args.mkdirp ?? true;
+  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  if (!overwrite) {
+    const { access: access2 } = await import("fs/promises");
+    try {
+      await access2(resolvedPath);
+      throw new Error(
+        `File already exists: ${resolvedPath}. Set overwrite=true to allow overwriting.`
+      );
+    } catch (err) {
+      if (err instanceof Error && !err.message.includes("already exists")) {
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (mkdirp) {
+    await (0, import_promises3.mkdir)((0, import_node_path2.dirname)(resolvedPath), { recursive: true });
+  }
+  await (0, import_promises3.writeFile)(resolvedPath, text, "utf-8");
+  const bytes = Buffer.byteLength(text, "utf-8");
+  const sha256 = (0, import_node_crypto.createHash)("sha256").update(text).digest("hex");
+  return {
+    result: {
+      path: resolvedPath,
+      bytes,
+      sha256
+    },
+    evidence: [
+      {
+        type: "file",
+        ref: resolvedPath,
+        summary: `Wrote ${bytes} bytes to ${resolvedPath} (sha256: ${sha256.slice(0, 12)}...)`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// fs/listDir.ts
+var import_promises4 = require("fs/promises");
+var import_node_path3 = require("path");
+var listDirHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const inputPath = args.path;
+  const maxEntries = args.maxEntries ?? 2e3;
+  const includeHidden = args.includeHidden ?? false;
+  const recursive = args.recursive ?? false;
+  const maxDepth = args.maxDepth ?? 5;
+  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const entries = [];
+  let truncated = false;
+  await walkDir(resolvedPath, "", entries, {
+    maxEntries,
+    includeHidden,
+    recursive,
+    maxDepth,
+    currentDepth: 0,
+    onTruncate: () => {
+      truncated = true;
+    }
+  });
+  return {
+    result: {
+      path: resolvedPath,
+      entries,
+      totalEntries: entries.length,
+      truncated
+    },
+    evidence: [
+      {
+        type: "tool",
+        ref: `core/fs.listDir:${resolvedPath}`,
+        summary: `Listed ${entries.length} entries in ${resolvedPath}${truncated ? " (truncated)" : ""}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+async function walkDir(basePath, relativePath, entries, options) {
+  if (entries.length >= options.maxEntries) {
+    options.onTruncate();
+    return;
+  }
+  const fullPath = relativePath ? (0, import_node_path3.resolve)(basePath, relativePath) : basePath;
+  const dirEntries = await (0, import_promises4.readdir)(fullPath, { withFileTypes: true });
+  for (const dirent of dirEntries) {
+    if (entries.length >= options.maxEntries) {
+      options.onTruncate();
+      return;
+    }
+    if (!options.includeHidden && dirent.name.startsWith(".")) {
+      continue;
+    }
+    const entryPath = (0, import_node_path3.join)(fullPath, dirent.name);
+    const entryRelative = relativePath ? (0, import_node_path3.join)(relativePath, dirent.name) : dirent.name;
+    let entryType;
+    if (dirent.isSymbolicLink()) {
+      entryType = "symlink";
+    } else if (dirent.isDirectory()) {
+      entryType = "directory";
+    } else if (dirent.isFile()) {
+      entryType = "file";
+    } else {
+      entryType = "other";
+    }
+    let size = 0;
+    let mtime = "";
+    try {
+      const entryStat = await (0, import_promises4.stat)(entryPath);
+      size = entryStat.size;
+      mtime = entryStat.mtime.toISOString();
+    } catch {
+    }
+    entries.push({
+      name: entryRelative,
+      type: entryType,
+      size,
+      mtime
+    });
+    if (options.recursive && entryType === "directory" && options.currentDepth < options.maxDepth) {
+      await walkDir(basePath, entryRelative, entries, {
+        ...options,
+        currentDepth: options.currentDepth + 1
+      });
+    }
+  }
+}
+
+// fs/searchText.ts
+var import_promises5 = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_readline = require("readline");
+var import_node_path4 = require("path");
+var searchTextHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const rootPath = args.root;
+  const query = args.query;
+  const glob = args.glob ?? "**/*.{md,txt,log,json,ts,js,py,java,scala}";
+  const maxMatches = args.maxMatches ?? 100;
+  const maxFiles = args.maxFiles ?? 500;
+  const resolvedRoot = await resolveSandboxedPath(rootPath, ctx.config.sandboxRoot);
+  let regex;
+  try {
+    regex = new RegExp(query, "i");
+  } catch {
+    regex = new RegExp(escapeRegExp(query), "i");
+  }
+  const extensions = parseGlobExtensions(glob);
+  const files = [];
+  await collectFiles(resolvedRoot, files, { maxFiles, extensions });
+  const matches = [];
+  let filesScanned = 0;
+  let truncated = false;
+  for (const filePath of files) {
+    if (matches.length >= maxMatches) {
+      truncated = true;
+      break;
+    }
+    filesScanned++;
+    await searchFile(filePath, resolvedRoot, regex, matches, maxMatches);
+  }
+  if (matches.length >= maxMatches) {
+    truncated = true;
+  }
+  return {
+    result: {
+      root: resolvedRoot,
+      query,
+      matches,
+      totalMatches: matches.length,
+      filesScanned,
+      truncated
+    },
+    evidence: [
+      {
+        type: "tool",
+        ref: `core/fs.searchText:${resolvedRoot}`,
+        summary: `Found ${matches.length} matches in ${filesScanned} files under ${resolvedRoot}${truncated ? " (truncated)" : ""}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+async function collectFiles(dirPath, files, options) {
+  if (files.length >= options.maxFiles) return;
+  let entries;
+  try {
+    entries = await (0, import_promises5.readdir)(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (files.length >= options.maxFiles) return;
+    const fullPath = (0, import_node_path4.join)(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      await collectFiles(fullPath, files, options);
+    } else if (entry.isFile()) {
+      if (options.extensions.size > 0) {
+        const ext = getExtension(entry.name);
+        if (!ext || !options.extensions.has(ext)) continue;
+      }
+      files.push(fullPath);
+    }
+  }
+}
+async function searchFile(filePath, root, regex, matches, maxMatches) {
+  const fileStat = await (0, import_promises5.stat)(filePath).catch(() => null);
+  if (!fileStat || fileStat.size > 1024 * 1024) return;
+  const stream = (0, import_node_fs.createReadStream)(filePath, { encoding: "utf-8" });
+  const rl = (0, import_node_readline.createInterface)({ input: stream, crlfDelay: Infinity });
+  let lineNo = 0;
+  for await (const line of rl) {
+    lineNo++;
+    if (matches.length >= maxMatches) {
+      stream.destroy();
+      break;
+    }
+    if (regex.test(line)) {
+      matches.push({
+        file: (0, import_node_path4.relative)(root, filePath),
+        lineNo,
+        excerpt: line.slice(0, 200)
+      });
+    }
+  }
+}
+function parseGlobExtensions(glob) {
+  const extensions = /* @__PURE__ */ new Set();
+  const braceMatch = glob.match(/\*\.\{([^}]+)\}/);
+  if (braceMatch) {
+    for (const ext of braceMatch[1].split(",")) {
+      extensions.add(ext.trim());
+    }
+  } else {
+    const simpleMatch = glob.match(/\*\.(\w+)/);
+    if (simpleMatch) {
+      extensions.add(simpleMatch[1]);
+    }
+  }
+  return extensions;
+}
+function getExtension(filename) {
+  const dotIdx = filename.lastIndexOf(".");
+  if (dotIdx === -1 || dotIdx === 0) return null;
+  return filename.slice(dotIdx + 1);
+}
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// fs/sha256.ts
+var import_node_fs2 = require("fs");
+var import_promises6 = require("fs/promises");
+var import_node_crypto2 = require("crypto");
+var sha256Handler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const inputPath = args.path;
+  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  const fileStat = await (0, import_promises6.stat)(resolvedPath);
+  const hash = await new Promise((resolve3, reject) => {
+    const hasher = (0, import_node_crypto2.createHash)("sha256");
+    const stream = (0, import_node_fs2.createReadStream)(resolvedPath);
+    stream.on("data", (chunk) => hasher.update(chunk));
+    stream.on("end", () => resolve3(hasher.digest("hex")));
+    stream.on("error", reject);
+  });
+  return {
+    result: {
+      sha256: hash,
+      path: resolvedPath,
+      bytes: fileStat.size
+    },
+    evidence: [
+      {
+        type: "file",
+        ref: resolvedPath,
+        summary: `SHA-256 of ${resolvedPath} (${fileStat.size} bytes): ${hash.slice(0, 16)}...`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// fs/deletePath.ts
+var import_promises7 = require("fs/promises");
+var deletePathHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const inputPath = args.path;
+  const recursive = args.recursive ?? false;
+  const confirm = args.confirm;
+  if (!confirm) {
+    throw new Error(
+      "Deletion not confirmed. Set confirm=true to proceed with deletion."
+    );
+  }
+  const resolvedPath = await resolveSandboxedPath(inputPath, ctx.config.sandboxRoot);
+  let realSandboxRoot;
+  try {
+    const { realpath: rp } = await import("fs/promises");
+    realSandboxRoot = await rp(ctx.config.sandboxRoot);
+  } catch {
+    realSandboxRoot = ctx.config.sandboxRoot;
+  }
+  if (resolvedPath === realSandboxRoot) {
+    throw new Error("Cannot delete the sandbox root directory.");
+  }
+  const fileStat = await (0, import_promises7.stat)(resolvedPath);
+  const isDirectory = fileStat.isDirectory();
+  if (isDirectory) {
+    if (recursive) {
+      await (0, import_promises7.rm)(resolvedPath, { recursive: true, force: true });
+    } else {
+      await (0, import_promises7.rmdir)(resolvedPath);
+    }
+  } else {
+    await (0, import_promises7.unlink)(resolvedPath);
+  }
+  return {
+    result: {
+      path: resolvedPath,
+      deleted: true,
+      type: isDirectory ? "directory" : "file"
+    },
+    evidence: [
+      {
+        type: "file",
+        ref: resolvedPath,
+        summary: `Deleted ${isDirectory ? "directory" : "file"}: ${resolvedPath}${recursive ? " (recursive)" : ""}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// security/ssrf.ts
+var import_promises8 = require("dns/promises");
+var import_agent_tool3 = require("@easynet/agent-tool");
+async function validateUrl(url, allowedHosts, blockedCidrs) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw (0, import_agent_tool3.createTaggedError)(
+      "HTTP_DISALLOWED_HOST",
+      `Invalid URL: ${url}`,
+      { url }
+    );
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw (0, import_agent_tool3.createTaggedError)(
+      "HTTP_DISALLOWED_HOST",
+      `Protocol not allowed: ${parsed.protocol}. Only http: and https: are supported.`,
+      { url, protocol: parsed.protocol }
+    );
+  }
+  const hostname = parsed.hostname;
+  if (!isHostAllowed(hostname, allowedHosts)) {
+    throw (0, import_agent_tool3.createTaggedError)(
+      "HTTP_DISALLOWED_HOST",
+      `Host "${hostname}" is not in the allowed hosts list`,
+      { url, hostname, allowedHosts }
+    );
+  }
+  try {
+    const { address } = await (0, import_promises8.lookup)(hostname);
+    if (isIpInBlockedCidrs(address, blockedCidrs)) {
+      throw (0, import_agent_tool3.createTaggedError)(
+        "HTTP_DISALLOWED_HOST",
+        `Host "${hostname}" resolves to blocked IP: ${address}`,
+        { url, hostname, resolvedIp: address }
+      );
+    }
+  } catch (err) {
+    if (err instanceof Error && err.kind === "HTTP_DISALLOWED_HOST") {
+      throw err;
+    }
+    throw (0, import_agent_tool3.createTaggedError)(
+      "HTTP_DISALLOWED_HOST",
+      `DNS resolution failed for host "${hostname}": ${err instanceof Error ? err.message : String(err)}`,
+      { url, hostname }
+    );
+  }
+  return parsed;
+}
+function isHostAllowed(hostname, allowedHosts) {
+  for (const pattern of allowedHosts) {
+    if (pattern.startsWith("*.")) {
+      const suffix = pattern.slice(1);
+      if (hostname.endsWith(suffix) || hostname === pattern.slice(2)) {
+        return true;
+      }
+    } else if (hostname === pattern) {
+      return true;
+    }
+  }
+  return false;
+}
+function isIpInBlockedCidrs(ip, cidrs) {
+  const normalizedIp = normalizeIp(ip);
+  if (!normalizedIp) return false;
+  for (const cidr of cidrs) {
+    if (cidr.includes(":")) {
+      if (!ip.includes(":")) continue;
+      if (isIpv6InCidr(ip, cidr)) return true;
+    } else {
+      if (isIpv4InCidr(normalizedIp, cidr)) return true;
+    }
+  }
+  return false;
+}
+function normalizeIp(ip) {
+  if (ip.startsWith("::ffff:")) {
+    return ip.slice(7);
+  }
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(ip)) {
+    return ip;
+  }
+  return null;
+}
+function isIpv4InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix) || prefix < 0 || prefix > 32) return false;
+  const ipNum = ipv4ToNum(ip);
+  const cidrNum = ipv4ToNum(cidrIp);
+  if (ipNum === null || cidrNum === null) return false;
+  const mask = prefix === 0 ? 0 : ~0 << 32 - prefix >>> 0;
+  return (ipNum & mask) === (cidrNum & mask);
+}
+function ipv4ToNum(ip) {
+  const parts = ip.split(".");
+  if (parts.length !== 4) return null;
+  let num = 0;
+  for (const part of parts) {
+    const n = parseInt(part, 10);
+    if (isNaN(n) || n < 0 || n > 255) return null;
+    num = num << 8 | n;
+  }
+  return num >>> 0;
+}
+function isIpv6InCidr(ip, cidr) {
+  const [cidrIp, prefixStr] = cidr.split("/");
+  if (!cidrIp || !prefixStr) return false;
+  const prefix = parseInt(prefixStr, 10);
+  if (isNaN(prefix)) return false;
+  const ipBytes = expandIpv6(ip);
+  const cidrBytes = expandIpv6(cidrIp);
+  if (!ipBytes || !cidrBytes) return false;
+  const fullBytes = Math.floor(prefix / 8);
+  for (let i = 0; i < fullBytes && i < 16; i++) {
+    if (ipBytes[i] !== cidrBytes[i]) return false;
+  }
+  const remainingBits = prefix % 8;
+  if (remainingBits > 0 && fullBytes < 16) {
+    const mask = ~0 << 8 - remainingBits & 255;
+    if ((ipBytes[fullBytes] & mask) !== (cidrBytes[fullBytes] & mask)) return false;
+  }
+  return true;
+}
+function expandIpv6(ip) {
+  const zoneIdx = ip.indexOf("%");
+  if (zoneIdx !== -1) ip = ip.slice(0, zoneIdx);
+  const parts = ip.split("::");
+  if (parts.length > 2) return null;
+  const bytes = new Array(16).fill(0);
+  const expandGroup = (group) => {
+    if (!group) return [];
+    return group.split(":").flatMap((hex) => {
+      const val = parseInt(hex || "0", 16);
+      return [val >> 8 & 255, val & 255];
+    });
+  };
+  if (parts.length === 1) {
+    const expanded = expandGroup(parts[0]);
+    if (expanded.length !== 16) return null;
+    return expanded;
+  }
+  const left = expandGroup(parts[0]);
+  const right = expandGroup(parts[1]);
+  if (left.length + right.length > 16) return null;
+  for (let i = 0; i < left.length; i++) bytes[i] = left[i];
+  for (let i = 0; i < right.length; i++) bytes[16 - right.length + i] = right[i];
+  return bytes;
+}
+
+// http/fetchText.ts
+var import_agent_tool4 = require("@easynet/agent-tool");
+var fetchTextHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const url = args.url;
+  const method = args.method ?? "GET";
+  const headers = args.headers ?? {};
+  const body = args.body ?? void 0;
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  if (!headers["User-Agent"] && !headers["user-agent"]) {
+    headers["User-Agent"] = ctx.config.httpUserAgent;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: body ?? void 0,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool4.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `Request to ${url} timed out after ${timeoutMs}ms`,
+        { url, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool4.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { url }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    throw (0, import_agent_tool4.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
+      { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
+    );
+  }
+  const text = await readResponseWithLimit(response, maxBytes, url);
+  const bytes = Buffer.byteLength(text, "utf-8");
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  return {
+    result: {
+      url,
+      status: response.status,
+      headers: responseHeaders,
+      text,
+      bytes
+    },
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `${method} ${url} \u2192 ${response.status} (${bytes} bytes)`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+async function readResponseWithLimit(response, maxBytes, url) {
+  if (!response.body) {
+    return response.text();
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        reader.cancel();
+        throw (0, import_agent_tool4.createTaggedError)(
+          "HTTP_TOO_LARGE",
+          `Response body exceeded limit of ${maxBytes} bytes while reading from ${url}`,
+          { url, bytesRead: totalBytes, limit: maxBytes }
+        );
+      }
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    chunks.push(decoder.decode());
+  } finally {
+    reader.releaseLock();
+  }
+  return chunks.join("");
+}
+
+// http/fetchJson.ts
+var import_agent_tool5 = require("@easynet/agent-tool");
+var fetchJsonHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const url = args.url;
+  const method = args.method ?? "GET";
+  const headers = args.headers ?? {};
+  const body = args.body ?? void 0;
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  if (!headers["Accept"] && !headers["accept"]) {
+    headers["Accept"] = "application/json";
+  }
+  if (!headers["User-Agent"] && !headers["user-agent"]) {
+    headers["User-Agent"] = ctx.config.httpUserAgent;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: body ?? void 0,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool5.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `Request to ${url} timed out after ${timeoutMs}ms`,
+        { url, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool5.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { url }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    throw (0, import_agent_tool5.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
+      { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
+    );
+  }
+  const text = await response.text();
+  const bytes = Buffer.byteLength(text, "utf-8");
+  if (bytes > maxBytes) {
+    throw (0, import_agent_tool5.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Response body ${bytes} bytes exceeds limit of ${maxBytes} bytes`,
+      { url, bytes, limit: maxBytes }
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw (0, import_agent_tool5.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `Failed to parse JSON response from ${url}: ${text.slice(0, 200)}`,
+      { url, status: response.status, textPreview: text.slice(0, 500) }
+    );
+  }
+  return {
+    result: {
+      url,
+      status: response.status,
+      json,
+      bytes
+    },
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `${method} ${url} \u2192 ${response.status} JSON (${bytes} bytes)`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// http/downloadFile.ts
+var import_promises9 = require("fs/promises");
+var import_node_crypto3 = require("crypto");
+var import_node_path5 = require("path");
+var import_agent_tool6 = require("@easynet/agent-tool");
+var downloadFileHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const url = args.url;
+  const destPath = args.destPath;
+  const headers = args.headers ?? {};
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  const maxBytes = args.maxBytes ?? ctx.config.maxDownloadBytes;
+  const overwrite = args.overwrite ?? false;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  const resolvedDest = await resolveSandboxedPath(destPath, ctx.config.sandboxRoot);
+  if (!overwrite) {
+    const { access: access2 } = await import("fs/promises");
+    try {
+      await access2(resolvedDest);
+      throw new Error(
+        `File already exists: ${resolvedDest}. Set overwrite=true to allow overwriting.`
+      );
+    } catch (err) {
+      if (err instanceof Error && !err.message.includes("already exists")) {
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!headers["User-Agent"] && !headers["user-agent"]) {
+    headers["User-Agent"] = ctx.config.httpUserAgent;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool6.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `Download from ${url} timed out after ${timeoutMs}ms`,
+        { url, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool6.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `Download failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { url }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    throw (0, import_agent_tool6.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Download Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
+      { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
+    );
+  }
+  if (!response.body) {
+    throw (0, import_agent_tool6.createTaggedError)("UPSTREAM_ERROR", `No response body from ${url}`, { url });
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  const hasher = (0, import_node_crypto3.createHash)("sha256");
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxBytes) {
+        reader.cancel();
+        throw (0, import_agent_tool6.createTaggedError)(
+          "HTTP_TOO_LARGE",
+          `Download from ${url} exceeded limit of ${maxBytes} bytes (received ${totalBytes})`,
+          { url, bytesRead: totalBytes, limit: maxBytes }
+        );
+      }
+      chunks.push(value);
+      hasher.update(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const sha256 = hasher.digest("hex");
+  await (0, import_promises9.mkdir)((0, import_node_path5.dirname)(resolvedDest), { recursive: true });
+  const buffer = Buffer.concat(chunks);
+  await (0, import_promises9.writeFile)(resolvedDest, buffer);
+  return {
+    result: {
+      destPath: resolvedDest,
+      bytes: totalBytes,
+      sha256,
+      status: response.status,
+      url
+    },
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `Downloaded ${totalBytes} bytes from ${url}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      {
+        type: "file",
+        ref: resolvedDest,
+        summary: `Saved to ${resolvedDest} (sha256: ${sha256.slice(0, 12)}...)`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// http/head.ts
+var import_agent_tool7 = require("@easynet/agent-tool");
+var headHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const url = args.url;
+  const headers = args.headers ?? {};
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  if (!headers["User-Agent"] && !headers["user-agent"]) {
+    headers["User-Agent"] = ctx.config.httpUserAgent;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "HEAD",
+      headers,
+      signal: controller.signal
+    });
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool7.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `HEAD request to ${url} timed out after ${timeoutMs}ms`,
+        { url, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool7.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `HEAD request failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { url }
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const responseHeaders = {};
+  response.headers.forEach((value, key) => {
+    responseHeaders[key] = value;
+  });
+  return {
+    result: {
+      url,
+      status: response.status,
+      headers: responseHeaders
+    },
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `HEAD ${url} \u2192 ${response.status}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// http/duckduckgoSearch.ts
+var import_agent_tool8 = require("@easynet/agent-tool");
+var DUCKDUCKGO_API = "https://api.duckduckgo.com/";
+var duckduckgoSearchHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const query = args.query?.trim();
+  if (!query) {
+    throw (0, import_agent_tool8.createTaggedError)("DUCKDUCKGO_INVALID", "query is required", {});
+  }
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  const maxResults = args.maxResults ?? 10;
+  const url = `${DUCKDUCKGO_API}?q=${encodeURIComponent(query)}&format=json`;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: { "User-Agent": ctx.config.httpUserAgent },
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool8.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `DuckDuckGo search timed out after ${timeoutMs}ms`,
+        { query, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool8.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `DuckDuckGo search failed: ${err instanceof Error ? err.message : String(err)}`,
+      { query }
+    );
+  }
+  clearTimeout(timer);
+  const maxBytes = ctx.config.maxHttpBytes;
+  const text = await response.text();
+  const bytes = Buffer.byteLength(text, "utf-8");
+  if (bytes > maxBytes) {
+    throw (0, import_agent_tool8.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `DuckDuckGo response ${bytes} bytes exceeds limit of ${maxBytes} bytes`,
+      { query, bytes, limit: maxBytes }
+    );
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    throw (0, import_agent_tool8.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `DuckDuckGo returned invalid JSON`,
+      { query, textPreview: text.slice(0, 200) }
+    );
+  }
+  const results = [];
+  if (Array.isArray(raw.Results)) {
+    for (const r of raw.Results.slice(0, maxResults)) {
+      if (r.FirstURL) {
+        results.push({
+          url: r.FirstURL,
+          title: r.Text ?? r.FirstURL,
+          snippet: r.Text
+        });
+      }
+    }
+  }
+  const relatedTopics = [];
+  if (Array.isArray(raw.RelatedTopics)) {
+    for (const t of raw.RelatedTopics.slice(0, maxResults)) {
+      const text2 = t.Text ?? t.Result;
+      if (text2) {
+        relatedTopics.push({ text: text2, url: t.FirstURL });
+      }
+    }
+  }
+  const result = {
+    query,
+    abstract: raw.Abstract ?? raw.AbstractText ?? void 0,
+    abstractUrl: raw.AbstractURL ?? void 0,
+    abstractSource: raw.AbstractSource ?? void 0,
+    heading: raw.Heading ?? void 0,
+    results,
+    relatedTopics
+  };
+  return {
+    result,
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `DuckDuckGo search: "${query}" \u2192 ${results.length} results`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// http/fetchPageMainContent.ts
+var import_node_html_parser = require("node-html-parser");
+var import_agent_tool9 = require("@easynet/agent-tool");
+var MAIN_SELECTORS = [
+  "main",
+  "article",
+  "[role='main']",
+  "#content",
+  "#main",
+  ".content",
+  ".main-content",
+  ".article-body",
+  ".post-content",
+  ".entry-content"
+];
+function extractMainContent(html) {
+  const root = (0, import_node_html_parser.parse)(html, { comment: false });
+  let title = "";
+  const titleEl = root.querySelector("title");
+  if (titleEl) {
+    title = (titleEl.textContent ?? "").trim().replace(/\s+/g, " ");
+  }
+  let mainEl = null;
+  for (const sel of MAIN_SELECTORS) {
+    mainEl = root.querySelector(sel);
+    if (mainEl) break;
+  }
+  if (!mainEl) {
+    const body = root.querySelector("body");
+    if (body) {
+      for (const tag of ["script", "style", "nav", "header", "footer", "aside", "noscript", "iframe"]) {
+        body.querySelectorAll(tag).forEach((el) => el.remove());
+      }
+      mainEl = body;
+    } else {
+      mainEl = root;
+    }
+  }
+  const text = (mainEl.textContent ?? "").trim().replace(/\s+/g, " ");
+  return { title, mainContent: text };
+}
+var fetchPageMainContentHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const url = args.url;
+  const timeoutMs = args.timeoutMs ?? ctx.config.defaultTimeoutMs;
+  const maxBytes = args.maxBytes ?? ctx.config.maxHttpBytes;
+  await validateUrl(url, ctx.config.allowedHosts, ctx.config.blockedCidrs);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: { "User-Agent": ctx.config.httpUserAgent },
+      signal: controller.signal
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      throw (0, import_agent_tool9.createTaggedError)(
+        "HTTP_TIMEOUT",
+        `Request to ${url} timed out after ${timeoutMs}ms`,
+        { url, timeoutMs }
+      );
+    }
+    throw (0, import_agent_tool9.createTaggedError)(
+      "UPSTREAM_ERROR",
+      `Fetch failed for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { url }
+    );
+  }
+  clearTimeout(timer);
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && parseInt(contentLength, 10) > maxBytes) {
+    throw (0, import_agent_tool9.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Response Content-Length ${contentLength} exceeds limit of ${maxBytes} bytes`,
+      { url, contentLength: parseInt(contentLength, 10), limit: maxBytes }
+    );
+  }
+  const rawText = await response.text();
+  const rawBytes = Buffer.byteLength(rawText, "utf-8");
+  if (rawBytes > maxBytes) {
+    throw (0, import_agent_tool9.createTaggedError)(
+      "HTTP_TOO_LARGE",
+      `Response body ${rawBytes} bytes exceeds limit of ${maxBytes} bytes`,
+      { url, bytes: rawBytes, limit: maxBytes }
+    );
+  }
+  const contentType = (response.headers.get("content-type") ?? "").toLowerCase();
+  const isHtml = contentType.includes("text/html");
+  let title;
+  let mainContent;
+  if (isHtml && rawText.trim().length > 0) {
+    try {
+      const extracted = extractMainContent(rawText);
+      title = extracted.title || void 0;
+      mainContent = extracted.mainContent;
+    } catch {
+      mainContent = rawText;
+    }
+  } else {
+    mainContent = rawText;
+  }
+  const bytes = Buffer.byteLength(mainContent, "utf-8");
+  return {
+    result: {
+      url,
+      status: response.status,
+      title,
+      mainContent,
+      bytes,
+      isHtml
+    },
+    evidence: [
+      {
+        type: "url",
+        ref: url,
+        summary: `${url} \u2192 ${response.status} main content (${bytes} bytes)`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// util/jsonSelect.ts
+var jsonSelectHandler = (async (args) => {
+  const json = args.json;
+  const path = args.path;
+  let jmespath;
+  try {
+    jmespath = await Promise.resolve().then(() => __toESM(require_jmespath(), 1));
+  } catch {
+    throw new Error(
+      "jmespath package is required for core/util.json.select. Install it with: npm install jmespath"
+    );
+  }
+  let value;
+  try {
+    value = jmespath.search(json, path);
+  } catch (err) {
+    throw new Error(
+      `JMESPath expression error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return {
+    result: { value },
+    evidence: [
+      {
+        type: "tool",
+        ref: "core/util.json.select",
+        summary: `Selected "${path}" from JSON \u2192 ${typeof value === "object" ? JSON.stringify(value).slice(0, 100) : String(value).slice(0, 100)}`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// util/truncate.ts
+var truncateHandler = (async (args) => {
+  const text = args.text;
+  const maxChars = args.maxChars;
+  const suffix = args.suffix ?? "...";
+  const originalLength = text.length;
+  if (text.length <= maxChars) {
+    return {
+      result: { text, truncated: false, originalLength },
+      evidence: [
+        {
+          type: "tool",
+          ref: "core/util.text.truncate",
+          summary: `Text not truncated (${originalLength} chars <= ${maxChars} max)`,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ]
+    };
+  }
+  const truncatedText = text.slice(0, maxChars - suffix.length) + suffix;
+  return {
+    result: { text: truncatedText, truncated: true, originalLength },
+    evidence: [
+      {
+        type: "tool",
+        ref: "core/util.text.truncate",
+        summary: `Truncated ${originalLength} chars to ${truncatedText.length} chars`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// util/hashText.ts
+var import_node_crypto4 = require("crypto");
+var hashTextHandler = (async (args) => {
+  const text = args.text;
+  const sha256 = (0, import_node_crypto4.createHash)("sha256").update(text, "utf-8").digest("hex");
+  return {
+    result: { sha256 },
+    evidence: [
+      {
+        type: "tool",
+        ref: "core/util.hash.sha256Text",
+        summary: `SHA-256 of ${text.length} chars: ${sha256.slice(0, 16)}...`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// util/now.ts
+var nowHandler = (async (args) => {
+  const timezone = args.timezone ?? "UTC";
+  const now = /* @__PURE__ */ new Date();
+  let formatted;
+  try {
+    formatted = new Intl.DateTimeFormat("en-US", {
+      timeZone: timezone,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false,
+      timeZoneName: "short"
+    }).format(now);
+  } catch {
+    formatted = now.toISOString();
+  }
+  return {
+    result: {
+      iso: now.toISOString(),
+      epochMs: now.getTime(),
+      timezone,
+      formatted
+    },
+    evidence: [
+      {
+        type: "tool",
+        ref: "core/util.time.now",
+        summary: `Current time: ${now.toISOString()} (${timezone})`,
+        createdAt: now.toISOString()
+      }
+    ]
+  };
+});
+
+// util/templateRender.ts
+var templateRenderHandler = (async (args) => {
+  const template = args.template;
+  const data = args.data;
+  let renderFn;
+  try {
+    const mod = await Promise.resolve().then(() => (init_mustache(), mustache_exports));
+    const mustache2 = mod.default ?? mod;
+    renderFn = mustache2.render.bind(mustache2);
+  } catch {
+    throw new Error(
+      "mustache package is required for core/util.template.render. Install it with: npm install mustache"
+    );
+  }
+  let text;
+  try {
+    text = renderFn(template, data);
+  } catch (err) {
+    throw new Error(
+      `Template rendering error: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return {
+    result: { text },
+    evidence: [
+      {
+        type: "tool",
+        ref: "core/util.template.render",
+        summary: `Rendered template (${template.length} chars) \u2192 ${text.length} chars output`,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    ]
+  };
+});
+
+// exec/runCommand.ts
+var import_node_child_process = require("child_process");
+var import_node_path6 = require("path");
+var import_agent_tool10 = require("@easynet/agent-tool");
+var runCommandHandler = (async (args) => {
+  const ctx = getBuiltinContext();
+  const { allowedCommands, maxCommandOutputBytes, commandTimeoutMs } = ctx.config;
+  if (!allowedCommands.length) {
+    throw (0, import_agent_tool10.createTaggedError)(
+      "EXEC_DISABLED",
+      "Exec is disabled: allowedCommands is empty",
+      {}
+    );
+  }
+  const rawCommand = args.command?.trim();
+  if (!rawCommand) {
+    throw (0, import_agent_tool10.createTaggedError)("EXEC_INVALID", "command is required", {});
+  }
+  const baseName = rawCommand.replace(/^.*\//, "").trim();
+  if (baseName !== rawCommand || /[;&|$`\s]/.test(rawCommand)) {
+    throw (0, import_agent_tool10.createTaggedError)(
+      "EXEC_INVALID",
+      "command must be a single executable name (no path, no shell chars)",
+      { command: rawCommand }
+    );
+  }
+  if (!allowedCommands.includes(baseName)) {
+    throw (0, import_agent_tool10.createTaggedError)(
+      "EXEC_NOT_ALLOWED",
+      `Command "${baseName}" is not in allowedCommands`,
+      { command: baseName, allowed: allowedCommands }
+    );
+  }
+  const cmdArgs = Array.isArray(args.args) ? args.args : [];
+  const timeoutMs = args.timeoutMs ?? commandTimeoutMs;
+  let cwd = (0, import_node_path6.resolve)(ctx.config.sandboxRoot);
+  if (args.cwd != null && args.cwd !== "") {
+    cwd = await resolveSandboxedPath(args.cwd, ctx.config.sandboxRoot);
+  }
+  return new Promise((resolvePromise, rejectPromise) => {
+    const proc = (0, import_node_child_process.spawn)(baseName, cmdArgs, {
+      cwd,
+      shell: false,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stdout = "";
+    let stderr = "";
+    let totalBytes = 0;
+    const append = (chunk, dest) => {
+      const len = Buffer.byteLength(chunk, "utf-8");
+      if (totalBytes + len > maxCommandOutputBytes) {
+        proc.kill("SIGKILL");
+        rejectPromise(
+          (0, import_agent_tool10.createTaggedError)(
+            "EXEC_OUTPUT_TOO_LARGE",
+            `Command output exceeded ${maxCommandOutputBytes} bytes`,
+            { maxBytes: maxCommandOutputBytes }
+          )
+        );
+        return;
+      }
+      totalBytes += len;
+      if (dest === "stdout") stdout += chunk;
+      else stderr += chunk;
+    };
+    proc.stdout?.setEncoding("utf-8");
+    proc.stderr?.setEncoding("utf-8");
+    proc.stdout?.on("data", (chunk) => append(chunk, "stdout"));
+    proc.stderr?.on("data", (chunk) => append(chunk, "stderr"));
+    const timeout = setTimeout(() => {
+      proc.kill("SIGKILL");
+      resolvePromise({
+        result: {
+          stdout,
+          stderr,
+          exitCode: null,
+          timedOut: true,
+          signal: "SIGKILL"
+        },
+        evidence: [
+          {
+            type: "exec",
+            summary: `Command "${baseName}" timed out after ${timeoutMs}ms`,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ]
+      });
+    }, timeoutMs);
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      rejectPromise(
+        (0, import_agent_tool10.createTaggedError)("EXEC_SPAWN_ERROR", err.message, { command: baseName })
+      );
+    });
+    proc.on("close", (code, signal) => {
+      clearTimeout(timeout);
+      resolvePromise({
+        result: {
+          stdout,
+          stderr,
+          exitCode: code,
+          timedOut: false,
+          signal: signal ?? void 0
+        },
+        evidence: [
+          {
+            type: "exec",
+            ref: baseName,
+            summary: `Ran ${baseName} (exit ${code ?? signal})`,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ]
+      });
+    });
+  });
+});
+
+// CoreToolsModule.ts
+var CORE_TOOL_MANIFEST = [
+  // Filesystem
+  {
+    name: "core/fs.readText",
+    kind: "core",
+    description: "Read a UTF-8 text file from the sandbox",
+    tags: ["filesystem", "read", "core"],
+    capabilities: ["read:fs"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/fs.writeText",
+    kind: "core",
+    description: "Write UTF-8 text to a file in the sandbox",
+    tags: ["filesystem", "write", "core"],
+    capabilities: ["write:fs"],
+    sideEffect: "local_write"
+  },
+  {
+    name: "core/fs.listDir",
+    kind: "core",
+    description: "List directory contents in the sandbox",
+    tags: ["filesystem", "read", "core"],
+    capabilities: ["read:fs"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/fs.searchText",
+    kind: "core",
+    description: "Search for text patterns in files within the sandbox",
+    tags: ["filesystem", "search", "core"],
+    capabilities: ["read:fs"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/fs.sha256",
+    kind: "core",
+    description: "Compute SHA-256 hash of a file in the sandbox",
+    tags: ["filesystem", "hash", "core"],
+    capabilities: ["read:fs"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/fs.deletePath",
+    kind: "core",
+    description: "Delete a file or directory in the sandbox (dangerous, requires explicit confirmation)",
+    tags: ["filesystem", "delete", "dangerous", "core"],
+    capabilities: ["danger:destructive", "write:fs"],
+    sideEffect: "destructive"
+  },
+  // HTTP
+  {
+    name: "core/http.fetchText",
+    kind: "core",
+    description: "Fetch a URL and return the response as text",
+    tags: ["http", "network", "core"],
+    capabilities: ["network"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/http.fetchJson",
+    kind: "core",
+    description: "Fetch a URL and return the response as parsed JSON",
+    tags: ["http", "network", "json", "core"],
+    capabilities: ["network"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/http.downloadFile",
+    kind: "core",
+    description: "Download a file from a URL to the sandbox",
+    tags: ["http", "network", "download", "core"],
+    capabilities: ["network", "write:fs"],
+    sideEffect: "local_write"
+  },
+  {
+    name: "core/http.head",
+    kind: "core",
+    description: "Send a HEAD request to get response headers without body",
+    tags: ["http", "network", "core"],
+    capabilities: ["network"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/http.duckduckgoSearch",
+    kind: "core",
+    description: "Search DuckDuckGo via Instant Answer API (no API key). Add api.duckduckgo.com to allowedHosts.",
+    tags: ["http", "search", "duckduckgo", "core"],
+    capabilities: ["network"],
+    sideEffect: "none"
+  },
+  {
+    name: "core/http.fetchPageMainContent",
+    kind: "core",
+    description: "Fetch a URL and return only the main content (main/article/body text). Strips nav, header, footer, scripts.",
+    tags: ["http", "network", "html", "main-content", "core"],
+    capabilities: ["network"],
+    sideEffect: "none"
+  },
+  // Utils
+  {
+    name: "core/util.json.select",
+    kind: "core",
+    description: "Select fields from JSON data using JMESPath expressions",
+    tags: ["util", "json", "core"],
+    capabilities: [],
+    sideEffect: "none"
+  },
+  {
+    name: "core/util.text.truncate",
+    kind: "core",
+    description: "Truncate text to a maximum character length with a suffix marker",
+    tags: ["util", "text", "core"],
+    capabilities: [],
+    sideEffect: "none"
+  },
+  {
+    name: "core/util.hash.sha256Text",
+    kind: "core",
+    description: "Compute SHA-256 hash of a text string",
+    tags: ["util", "hash", "core"],
+    capabilities: [],
+    sideEffect: "none"
+  },
+  {
+    name: "core/util.time.now",
+    kind: "core",
+    description: "Get the current time in various formats",
+    tags: ["util", "time", "core"],
+    capabilities: [],
+    sideEffect: "none"
+  },
+  {
+    name: "core/util.template.render",
+    kind: "core",
+    description: "Render a Mustache template with data",
+    tags: ["util", "template", "core"],
+    capabilities: [],
+    sideEffect: "none"
+  },
+  // Exec
+  {
+    name: "core/exec.runCommand",
+    kind: "core",
+    description: "Run a Linux command in the sandbox (allowlist, timeout, no shell). Command name only; args as array.",
+    tags: ["exec", "shell", "linux", "core"],
+    capabilities: ["exec"],
+    sideEffect: "local_write"
+  }
+];
+var CORE_TOOL_HANDLERS = [
+  readTextHandler,
+  writeTextHandler,
+  listDirHandler,
+  searchTextHandler,
+  sha256Handler,
+  deletePathHandler,
+  fetchTextHandler,
+  fetchJsonHandler,
+  downloadFileHandler,
+  headHandler,
+  duckduckgoSearchHandler,
+  fetchPageMainContentHandler,
+  jsonSelectHandler,
+  truncateHandler,
+  hashTextHandler,
+  nowHandler,
+  templateRenderHandler,
+  runCommandHandler
+];
+var readTextSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[0]);
+var writeTextSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[1]);
+var listDirSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[2]);
+var searchTextSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[3]);
+var sha256Spec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[4]);
+var deletePathSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[5]);
+var fetchTextSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[6]);
+var fetchJsonSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[7]);
+var downloadFileSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[8]);
+var headSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[9]);
+var jsonSelectSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[10]);
+var truncateSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[11]);
+var hashTextSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[12]);
+var nowSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[13]);
+var templateRenderSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[14]);
+var runCommandSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[15]);
+var duckduckgoSearchSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[16]);
+var fetchPageMainContentSpec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[17]);
+var CORE_GROUP_PREFIX = {
+  fs: "core/fs.",
+  http: "core/http.",
+  util: "core/util.",
+  exec: "core/exec."
+};
+function registerCoreTools(registry, userConfig, options) {
+  const config = {
+    ...DEFAULT_CORE_TOOLS_CONFIG,
+    ...userConfig
+  };
+  const adapter = new CoreAdapter(config);
+  const onlySet = options?.only?.length ? new Set(options.only) : null;
+  const allowedPrefixes = !onlySet && options?.groups?.length ? options.groups.map((g) => CORE_GROUP_PREFIX[g]) : null;
+  for (let i = 0; i < CORE_TOOL_MANIFEST.length; i++) {
+    const spec = (0, import_core.createToolSpec)(CORE_TOOL_MANIFEST[i]);
+    if (onlySet && !onlySet.has(spec.name)) continue;
+    if (allowedPrefixes && !allowedPrefixes.some((p) => spec.name.startsWith(p))) {
+      continue;
+    }
+    const handler = CORE_TOOL_HANDLERS[i];
+    registry.register(spec);
+    adapter.registerHandler(spec.name, handler);
+  }
+  return adapter;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CoreAdapter,
+  DEFAULT_CORE_TOOLS_CONFIG,
+  deletePathSpec,
+  downloadFileSpec,
+  duckduckgoSearchSpec,
+  fetchJsonSpec,
+  fetchPageMainContentSpec,
+  fetchTextSpec,
+  getBuiltinContext,
+  hashTextSpec,
+  headSpec,
+  isIpInBlockedCidrs,
+  jsonSelectSpec,
+  listDirSpec,
+  nowHandler,
+  nowSpec,
+  readTextSpec,
+  registerCoreTools,
+  resolveSandboxedPath,
+  runCommandSpec,
+  runWithBuiltinContext,
+  searchTextSpec,
+  sha256Spec,
+  templateRenderSpec,
+  truncateSpec,
+  validateUrl,
+  writeTextSpec
+});
+/*! Bundled license information:
+
+mustache/mustache.mjs:
+  (*!
+   * mustache.js - Logic-less {{mustache}} templates with JavaScript
+   * http://github.com/janl/mustache.js
+   *)
+*/
+//# sourceMappingURL=index.cjs.map