@midscene/core 0.8.16 → 0.8.17-beta-20250103065754.0

package/dist/lib/ai-model.js

@@ -33,6 +33,1046 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/.pnpm/lex@1.7.9/node_modules/lex/lexer.js
+var require_lexer = __commonJS({
+  "../../node_modules/.pnpm/lex@1.7.9/node_modules/lex/lexer.js"(exports, module2) {
+    "use strict";
+    if (typeof module2 === "object" && typeof module2.exports === "object")
+      module2.exports = Lexer;
+    Lexer.defunct = function(chr) {
+      throw new Error("Unexpected character at index " + (this.index - 1) + ": " + chr);
+    };
+    function Lexer(defunct) {
+      if (typeof defunct !== "function")
+        defunct = Lexer.defunct;
+      var tokens = [];
+      var rules = [];
+      var remove = 0;
+      this.state = 0;
+      this.index = 0;
+      this.input = "";
+      this.addRule = function(pattern, action, start) {
+        var global = pattern.global;
+        if (!global) {
+          var flags = "g";
+          if (pattern.multiline)
+            flags += "m";
+          if (pattern.ignoreCase)
+            flags += "i";
+          pattern = new RegExp(pattern.source, flags);
+        }
+        if (Object.prototype.toString.call(start) !== "[object Array]")
+          start = [0];
+        rules.push({
+          pattern,
+          global,
+          action,
+          start
+        });
+        return this;
+      };
+      this.setInput = function(input) {
+        remove = 0;
+        this.state = 0;
+        this.index = 0;
+        tokens.length = 0;
+        this.input = input;
+        return this;
+      };
+      this.lex = function() {
+        if (tokens.length)
+          return tokens.shift();
+        this.reject = true;
+        while (this.index <= this.input.length) {
+          var matches = scan.call(this).splice(remove);
+          var index = this.index;
+          while (matches.length) {
+            if (this.reject) {
+              var match = matches.shift();
+              var result = match.result;
+              var length = match.length;
+              this.index += length;
+              this.reject = false;
+              remove++;
+              var token = match.action.apply(this, result);
+              if (this.reject)
+                this.index = result.index;
+              else if (typeof token !== "undefined") {
+                switch (Object.prototype.toString.call(token)) {
+                  case "[object Array]":
+                    tokens = token.slice(1);
+                    token = token[0];
+                  default:
+                    if (length)
+                      remove = 0;
+                    return token;
+                }
+              }
+            } else
+              break;
+          }
+          var input = this.input;
+          if (index < input.length) {
+            if (this.reject) {
+              remove = 0;
+              var token = defunct.call(this, input.charAt(this.index++));
+              if (typeof token !== "undefined") {
+                if (Object.prototype.toString.call(token) === "[object Array]") {
+                  tokens = token.slice(1);
+                  return token[0];
+                } else
+                  return token;
+              }
+            } else {
+              if (this.index !== index)
+                remove = 0;
+              this.reject = true;
+            }
+          } else if (matches.length)
+            this.reject = true;
+          else
+            break;
+        }
+      };
+      function scan() {
+        var matches = [];
+        var index = 0;
+        var state = this.state;
+        var lastIndex = this.index;
+        var input = this.input;
+        for (var i = 0, length = rules.length; i < length; i++) {
+          var rule = rules[i];
+          var start = rule.start;
+          var states = start.length;
+          if (!states || start.indexOf(state) >= 0 || state % 2 && states === 1 && !start[0]) {
+            var pattern = rule.pattern;
+            pattern.lastIndex = lastIndex;
+            var result = pattern.exec(input);
+            if (result && result.index === lastIndex) {
+              var j = matches.push({
+                result,
+                action: rule.action,
+                length: result[0].length
+              });
+              if (rule.global)
+                index = j;
+              while (--j > index) {
+                var k = j - 1;
+                if (matches[j].length > matches[k].length) {
+                  var temple = matches[j];
+                  matches[j] = matches[k];
+                  matches[k] = temple;
+                }
+              }
+            }
+          }
+        }
+        return matches;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/string.fromcodepoint@0.2.1/node_modules/string.fromcodepoint/fromcodepoint.js
+var require_fromcodepoint = __commonJS({
+  "../../node_modules/.pnpm/string.fromcodepoint@0.2.1/node_modules/string.fromcodepoint/fromcodepoint.js"() {
+    "use strict";
+    if (!String.fromCodePoint) {
+      (function() {
+        var defineProperty = function() {
+          try {
+            var object = {};
+            var $defineProperty = Object.defineProperty;
+            var result = $defineProperty(object, object, object) && $defineProperty;
+          } catch (error) {
+          }
+          return result;
+        }();
+        var stringFromCharCode = String.fromCharCode;
+        var floor = Math.floor;
+        var fromCodePoint = function(_) {
+          var MAX_SIZE = 16384;
+          var codeUnits = [];
+          var highSurrogate;
+          var lowSurrogate;
+          var index = -1;
+          var length = arguments.length;
+          if (!length) {
+            return "";
+          }
+          var result = "";
+          while (++index < length) {
+            var codePoint = Number(arguments[index]);
+            if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+            codePoint < 0 || // not a valid Unicode code point
+            codePoint > 1114111 || // not a valid Unicode code point
+            floor(codePoint) != codePoint) {
+              throw RangeError("Invalid code point: " + codePoint);
+            }
+            if (codePoint <= 65535) {
+              codeUnits.push(codePoint);
+            } else {
+              codePoint -= 65536;
+              highSurrogate = (codePoint >> 10) + 55296;
+              lowSurrogate = codePoint % 1024 + 56320;
+              codeUnits.push(highSurrogate, lowSurrogate);
+            }
+            if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+              result += stringFromCharCode.apply(null, codeUnits);
+              codeUnits.length = 0;
+            }
+          }
+          return result;
+        };
+        if (defineProperty) {
+          defineProperty(String, "fromCodePoint", {
+            "value": fromCodePoint,
+            "configurable": true,
+            "writable": true
+          });
+        } else {
+          String.fromCodePoint = fromCodePoint;
+        }
+      })();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/unescape-js@1.1.4/node_modules/unescape-js/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/.pnpm/unescape-js@1.1.4/node_modules/unescape-js/dist/index.js"(exports, module2) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    require_fromcodepoint();
+    var jsEscapeRegex = /\\(u\{([0-9A-Fa-f]+)\}|u([0-9A-Fa-f]{4})|x([0-9A-Fa-f]{2})|([1-7][0-7]{0,2}|[0-7]{2,3})|(['"tbrnfv0\\]))|\\U([0-9A-Fa-f]{8})/g;
+    var usualEscapeSequences = {
+      "0": "\0",
+      "b": "\b",
+      "f": "\f",
+      "n": "\n",
+      "r": "\r",
+      "t": "	",
+      "v": "\v",
+      "'": "'",
+      '"': '"',
+      "\\": "\\"
+    };
+    var fromHex = function fromHex2(str) {
+      return String.fromCodePoint(parseInt(str, 16));
+    };
+    var fromOct = function fromOct2(str) {
+      return String.fromCodePoint(parseInt(str, 8));
+    };
+    var _default = function _default2(string) {
+      return string.replace(jsEscapeRegex, function(_, __, varHex, longHex, shortHex, octal, specialCharacter, python) {
+        if (varHex !== void 0) {
+          return fromHex(varHex);
+        } else if (longHex !== void 0) {
+          return fromHex(longHex);
+        } else if (shortHex !== void 0) {
+          return fromHex(shortHex);
+        } else if (octal !== void 0) {
+          return fromOct(octal);
+        } else if (python !== void 0) {
+          return fromHex(python);
+        } else {
+          return usualEscapeSequences[specialCharacter];
+        }
+      });
+    };
+    exports.default = _default;
+    module2.exports = exports.default;
+  }
+});
+
+// ../../node_modules/.pnpm/utf8@3.0.0/node_modules/utf8/utf8.js
+var require_utf8 = __commonJS({
+  "../../node_modules/.pnpm/utf8@3.0.0/node_modules/utf8/utf8.js"(exports) {
+    "use strict";
+    (function(root) {
+      var stringFromCharCode = String.fromCharCode;
+      function ucs2decode(string) {
+        var output = [];
+        var counter = 0;
+        var length = string.length;
+        var value;
+        var extra;
+        while (counter < length) {
+          value = string.charCodeAt(counter++);
+          if (value >= 55296 && value <= 56319 && counter < length) {
+            extra = string.charCodeAt(counter++);
+            if ((extra & 64512) == 56320) {
+              output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
+            } else {
+              output.push(value);
+              counter--;
+            }
+          } else {
+            output.push(value);
+          }
+        }
+        return output;
+      }
+      function ucs2encode(array) {
+        var length = array.length;
+        var index = -1;
+        var value;
+        var output = "";
+        while (++index < length) {
+          value = array[index];
+          if (value > 65535) {
+            value -= 65536;
+            output += stringFromCharCode(value >>> 10 & 1023 | 55296);
+            value = 56320 | value & 1023;
+          }
+          output += stringFromCharCode(value);
+        }
+        return output;
+      }
+      function checkScalarValue(codePoint) {
+        if (codePoint >= 55296 && codePoint <= 57343) {
+          throw Error(
+            "Lone surrogate U+" + codePoint.toString(16).toUpperCase() + " is not a scalar value"
+          );
+        }
+      }
+      function createByte(codePoint, shift) {
+        return stringFromCharCode(codePoint >> shift & 63 | 128);
+      }
+      function encodeCodePoint(codePoint) {
+        if ((codePoint & 4294967168) == 0) {
+          return stringFromCharCode(codePoint);
+        }
+        var symbol = "";
+        if ((codePoint & 4294965248) == 0) {
+          symbol = stringFromCharCode(codePoint >> 6 & 31 | 192);
+        } else if ((codePoint & 4294901760) == 0) {
+          checkScalarValue(codePoint);
+          symbol = stringFromCharCode(codePoint >> 12 & 15 | 224);
+          symbol += createByte(codePoint, 6);
+        } else if ((codePoint & 4292870144) == 0) {
+          symbol = stringFromCharCode(codePoint >> 18 & 7 | 240);
+          symbol += createByte(codePoint, 12);
+          symbol += createByte(codePoint, 6);
+        }
+        symbol += stringFromCharCode(codePoint & 63 | 128);
+        return symbol;
+      }
+      function utf8encode(string) {
+        var codePoints = ucs2decode(string);
+        var length = codePoints.length;
+        var index = -1;
+        var codePoint;
+        var byteString = "";
+        while (++index < length) {
+          codePoint = codePoints[index];
+          byteString += encodeCodePoint(codePoint);
+        }
+        return byteString;
+      }
+      function readContinuationByte() {
+        if (byteIndex >= byteCount) {
+          throw Error("Invalid byte index");
+        }
+        var continuationByte = byteArray[byteIndex] & 255;
+        byteIndex++;
+        if ((continuationByte & 192) == 128) {
+          return continuationByte & 63;
+        }
+        throw Error("Invalid continuation byte");
+      }
+      function decodeSymbol() {
+        var byte1;
+        var byte2;
+        var byte3;
+        var byte4;
+        var codePoint;
+        if (byteIndex > byteCount) {
+          throw Error("Invalid byte index");
+        }
+        if (byteIndex == byteCount) {
+          return false;
+        }
+        byte1 = byteArray[byteIndex] & 255;
+        byteIndex++;
+        if ((byte1 & 128) == 0) {
+          return byte1;
+        }
+        if ((byte1 & 224) == 192) {
+          byte2 = readContinuationByte();
+          codePoint = (byte1 & 31) << 6 | byte2;
+          if (codePoint >= 128) {
+            return codePoint;
+          } else {
+            throw Error("Invalid continuation byte");
+          }
+        }
+        if ((byte1 & 240) == 224) {
+          byte2 = readContinuationByte();
+          byte3 = readContinuationByte();
+          codePoint = (byte1 & 15) << 12 | byte2 << 6 | byte3;
+          if (codePoint >= 2048) {
+            checkScalarValue(codePoint);
+            return codePoint;
+          } else {
+            throw Error("Invalid continuation byte");
+          }
+        }
+        if ((byte1 & 248) == 240) {
+          byte2 = readContinuationByte();
+          byte3 = readContinuationByte();
+          byte4 = readContinuationByte();
+          codePoint = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4;
+          if (codePoint >= 65536 && codePoint <= 1114111) {
+            return codePoint;
+          }
+        }
+        throw Error("Invalid UTF-8 detected");
+      }
+      var byteArray;
+      var byteCount;
+      var byteIndex;
+      function utf8decode(byteString) {
+        byteArray = ucs2decode(byteString);
+        byteCount = byteArray.length;
+        byteIndex = 0;
+        var codePoints = [];
+        var tmp;
+        while ((tmp = decodeSymbol()) !== false) {
+          codePoints.push(tmp);
+        }
+        return ucs2encode(codePoints);
+      }
+      root.version = "3.0.0";
+      root.encode = utf8encode;
+      root.decode = utf8decode;
+    })(typeof exports === "undefined" ? exports.utf8 = {} : exports);
+  }
+});
+
+// ../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/lexer.js
+var require_lexer2 = __commonJS({
+  "../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/lexer.js"(exports, module2) {
+    "use strict";
+    var Lexer = require_lexer();
+    var unescapeJs = require_dist();
+    var utf8 = require_utf8();
+    var LEX_FLOAT = 6;
+    var LEX_INT = 7;
+    var LEX_QUOTE = 11;
+    var LEX_RB = 12;
+    var LEX_RCB = 13;
+    var LEX_TOKEN = 14;
+    var LEX_COLON = -1;
+    var LEX_COMMA = -2;
+    var LEX_LCB = -3;
+    var LEX_LB = -4;
+    var LEX_DOT = -5;
+    var lexSpc = [
+      [/\s*:\s*/, LEX_COLON],
+      [/\s*,\s*/, LEX_COMMA],
+      [/\s*{\s*/, LEX_LCB],
+      [/\s*}\s*/, LEX_RCB],
+      [/\s*\[\s*/, LEX_LB],
+      [/\s*\]\s*/, LEX_RB],
+      [/\s*\.\s*/, LEX_DOT]
+      // TODO: remove?
+    ];
+    function parseString(str) {
+      str = str.replace(/\\\//, "/");
+      return unescapeJs(str);
+    }
+    function getLexer(string) {
+      let lexer = new Lexer();
+      let col = 0;
+      let row = 0;
+      lexer.addRule(/"((?:\\.|[^"])*?)($|")/, (lexeme, txt) => {
+        col += lexeme.length;
+        return { type: LEX_QUOTE, value: parseString(txt), row, col, single: false };
+      });
+      lexer.addRule(/'((?:\\.|[^'])*?)($|'|(",?[ \t]*\n))/, (lexeme, txt) => {
+        col += lexeme.length;
+        return { type: LEX_QUOTE, value: parseString(txt), row, col, single: true };
+      });
+      lexer.addRule(/[\-0-9]*\.[0-9]*([eE][\+\-]?)?[0-9]*(?:\s*)/, (lexeme) => {
+        col += lexeme.length;
+        return { type: LEX_FLOAT, value: parseFloat(lexeme), row, col };
+      });
+      lexer.addRule(/\-?[0-9]+([eE][\+\-]?)[0-9]*(?:\s*)/, (lexeme) => {
+        col += lexeme.length;
+        return { type: LEX_FLOAT, value: parseFloat(lexeme), row, col };
+      });
+      lexer.addRule(/\-?[0-9]+(?:\s*)/, (lexeme) => {
+        col += lexeme.length;
+        return { type: LEX_INT, value: parseInt(lexeme), row, col };
+      });
+      lexSpc.forEach((item) => {
+        lexer.addRule(item[0], (lexeme) => {
+          col += lexeme.length;
+          return { type: item[1], value: lexeme, row, col };
+        });
+      });
+      lexer.addRule(/\s/, (lexeme) => {
+        if (lexeme == "\n") {
+          col = 0;
+          row++;
+        } else {
+          col += lexeme.length;
+        }
+      });
+      lexer.addRule(/\S[ \t]*/, (lexeme) => {
+        col += lexeme.length;
+        let lt = LEX_TOKEN;
+        let val = lexeme;
+        return { type: lt, value: val, row, col };
+      });
+      lexer.setInput(string);
+      return lexer;
+    }
+    module2.exports.lexString = lexString;
+    function lexString(str, emit) {
+      let lex = getLexer(str);
+      let token = "";
+      while (token = lex.lex()) {
+        emit(token);
+      }
+    }
+    module2.exports.getAllTokens = getAllTokens;
+    function getAllTokens(str) {
+      let arr = [];
+      let emit = function(i) {
+        arr.push(i);
+      };
+      lexString(str, emit);
+      return arr;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/parser.js
+var require_parser = __commonJS({
+  "../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/parser.js"(exports, module2) {
+    "use strict";
+    var lexer = require_lexer2();
+    var LEX_KV = 0;
+    var LEX_KVLIST = 1;
+    var LEX_VLIST = 2;
+    var LEX_BOOLEAN = 3;
+    var LEX_COVALUE = 4;
+    var LEX_CVALUE = 5;
+    var LEX_FLOAT = 6;
+    var LEX_INT = 7;
+    var LEX_KEY = 8;
+    var LEX_LIST = 9;
+    var LEX_OBJ = 10;
+    var LEX_QUOTE = 11;
+    var LEX_RB = 12;
+    var LEX_RCB = 13;
+    var LEX_TOKEN = 14;
+    var LEX_VALUE = 15;
+    var LEX_COLON = -1;
+    var LEX_COMMA = -2;
+    var LEX_LCB = -3;
+    var LEX_LB = -4;
+    function extendArray(arr) {
+      if (arr.peek == null) {
+        Object.defineProperty(arr, "peek", {
+          enumerable: false,
+          value: function() {
+            return this[this.length - 1];
+          }
+        });
+      }
+      if (arr.last == null) {
+        Object.defineProperty(arr, "last", {
+          enumerable: false,
+          value: function(i) {
+            return this[this.length - (1 + i)];
+          }
+        });
+      }
+    }
+    function is(obj, prop) {
+      return obj && obj.hasOwnProperty("type") && obj.type == prop;
+    }
+    function log(str) {
+    }
+    module2.exports.parse = parse;
+    function parse(text, dupKeys) {
+      let stack = [];
+      let tokens = [];
+      extendArray(stack);
+      extendArray(tokens);
+      let emit = function(t) {
+        tokens.push(t);
+      };
+      lexer.lexString(text, emit);
+      if (tokens[0].type == LEX_LB && tokens.last(0).type != LEX_RB) {
+        tokens.push({ type: LEX_RB, value: "]", row: -1, col: -1 });
+      }
+      if (tokens[0].type == LEX_LCB && tokens.last(0).type != LEX_RCB) {
+        tokens.push({ type: LEX_RCB, value: "}", row: -1, col: -1 });
+      }
+      for (let i = 0; i < tokens.length; i++) {
+        log("Shifting " + tokens[i].type);
+        stack.push(tokens[i]);
+        log(stack);
+        log("Reducing...");
+        while (reduce(stack)) {
+          log(stack);
+          log("Reducing...");
+        }
+      }
+      if (stack.length == 1 && stack[0].type == LEX_KVLIST) {
+        log("Pre-compile error fix 1");
+        stack = [{ type: LEX_OBJ, value: stack[0].value }];
+      }
+      return compileOST(stack[0], dupKeys);
+    }
+    function reduce(stack) {
+      let next = stack.pop();
+      switch (next.type) {
+        case LEX_KEY:
+          if (next.value.trim() == "true") {
+            log("Rule 5");
+            stack.push({ "type": LEX_BOOLEAN, "value": "true" });
+            return true;
+          }
+          if (next.value.trim() == "false") {
+            log("Rule 6");
+            stack.push({ "type": LEX_BOOLEAN, "value": "false" });
+            return true;
+          }
+          if (next.value.trim() == "null") {
+            log("Rule 7");
+            stack.push({ "type": LEX_VALUE, "value": null });
+            return true;
+          }
+          break;
+        case LEX_TOKEN:
+          if (is(stack.peek(), LEX_KEY)) {
+            log("Rule 11a");
+            stack.peek().value += next.value;
+            return true;
+          }
+          log("Rule 11c");
+          stack.push({ type: LEX_KEY, value: next.value });
+          return true;
+        case LEX_INT:
+          if (is(next, LEX_INT) && is(stack.peek(), LEX_KEY)) {
+            log("Rule 11b");
+            stack.peek().value += next.value;
+            return true;
+          }
+          log("Rule 11f");
+          next.type = LEX_VALUE;
+          stack.push(next);
+          return true;
+        case LEX_QUOTE:
+          log("Rule 11d");
+          next.type = LEX_VALUE;
+          next.value = next.value;
+          stack.push(next);
+          return true;
+        case LEX_BOOLEAN:
+          log("Rule 11e");
+          next.type = LEX_VALUE;
+          if (next.value == "true") {
+            next.value = true;
+          } else {
+            next.value = false;
+          }
+          stack.push(next);
+          return true;
+        case LEX_FLOAT:
+          log("Rule 11g");
+          next.type = LEX_VALUE;
+          stack.push(next);
+          return true;
+        case LEX_VALUE:
+          if (is(stack.peek(), LEX_COMMA)) {
+            log("Rule 12");
+            next.type = LEX_CVALUE;
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_COLON)) {
+            log("Rule 13");
+            next.type = LEX_COVALUE;
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_VALUE)) {
+            log("Error rule 1");
+            let middleVal = stack.pop();
+            stack.peek().value += '"' + middleVal.value + '"';
+            stack.peek().value += next.value;
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_VLIST)) {
+            log("Error rule 2");
+            let middleVal = stack.pop();
+            let oldLastVal = stack.peek().value.pop();
+            oldLastVal += '"' + middleVal.value + '"';
+            oldLastVal += next.value;
+            stack.peek().value.push(oldLastVal);
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_KVLIST)) {
+            log("Error rule 3");
+            let middleVal = stack.pop();
+            let oldLastVal = stack.peek().value.pop();
+            const qChar = next.single ? "'" : '"';
+            oldLastVal.value += qChar + middleVal.value + qChar;
+            oldLastVal.value += next.value;
+            stack.peek().value.push(oldLastVal);
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY)) {
+            log("Error rule 4");
+            let keyValue = stack.pop().value;
+            next.value = keyValue + next.value;
+            stack.push(next);
+            return true;
+          }
+          break;
+        case LEX_LIST:
+          if (is(next, LEX_LIST) && is(stack.peek(), LEX_COMMA)) {
+            log("Rule 12a");
+            next.type = LEX_CVALUE;
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_COLON)) {
+            log("Rule 13a");
+            next.type = LEX_COVALUE;
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          break;
+        case LEX_OBJ:
+          if (is(stack.peek(), LEX_COMMA)) {
+            log("Rule 12b");
+            let toPush = { "type": LEX_CVALUE, "value": next };
+            stack.pop();
+            stack.push(toPush);
+            return true;
+          }
+          if (is(stack.peek(), LEX_COLON)) {
+            log("Rule 13b");
+            let toPush = { "type": LEX_COVALUE, "value": next };
+            stack.pop();
+            stack.push(toPush);
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY)) {
+            log("Error rule 9");
+            let key = stack.pop();
+            stack.push({ "type": LEX_KV, "key": key.value.trim(), "value": next });
+            return true;
+          }
+          break;
+        case LEX_CVALUE:
+          if (is(stack.peek(), LEX_VLIST)) {
+            log("Rule 14");
+            stack.peek().value.push(next.value);
+            return true;
+          }
+          log("Rule 15");
+          stack.push({ "type": LEX_VLIST, "value": [next.value] });
+          return true;
+        case LEX_VLIST:
+          if (is(stack.peek(), LEX_VALUE)) {
+            log("Rule 15a");
+            next.value.unshift(stack.peek().value);
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_LIST)) {
+            log("Rule 15b");
+            next.value.unshift(stack.peek().value);
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_OBJ)) {
+            log("Rule 15c");
+            next.value.unshift(stack.peek());
+            stack.pop();
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && (stack.last(1), LEX_COMMA)) {
+            log("Error rule 7");
+            let l = stack.pop();
+            stack.push({ type: LEX_VALUE, "value": l.value });
+            log("Start subreduce... (" + l.value + ")");
+            while (reduce(stack))
+              ;
+            log("End subreduce");
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_VLIST)) {
+            log("Error rule 8");
+            stack.peek().value.push(next.value[0]);
+            return true;
+          }
+          break;
+        case LEX_COVALUE:
+          if (is(stack.peek(), LEX_KEY) || is(stack.peek(), LEX_VALUE) || is(stack.peek(), LEX_VLIST)) {
+            log("Rule 16");
+            let key = stack.pop();
+            stack.push({ "type": LEX_KV, "key": key.value, "value": next.value });
+            return true;
+          }
+          throw new Error("Got a :value that can't be handled at line " + next.row + ":" + next.col);
+        case LEX_KV:
+          if (is(stack.last(0), LEX_COMMA) && is(stack.last(1), LEX_KVLIST)) {
+            log("Rule 17");
+            stack.last(1).value.push(next);
+            stack.pop();
+            return true;
+          }
+          log("Rule 18");
+          stack.push({ "type": LEX_KVLIST, "value": [next] });
+          return true;
+        case LEX_KVLIST:
+          if (is(stack.peek(), LEX_KVLIST)) {
+            log("Rule 17a");
+            next.value.forEach(function(i) {
+              stack.peek().value.push(i);
+            });
+            return true;
+          }
+          break;
+        case LEX_RB:
+          if (is(stack.peek(), LEX_VLIST) && is(stack.last(1), LEX_LB)) {
+            log("Rule 19");
+            let l = stack.pop();
+            stack.pop();
+            stack.push({ "type": LEX_LIST, "value": l.value });
+            return true;
+          }
+          if (is(stack.peek(), LEX_LIST) && is(stack.last(1), LEX_LB)) {
+            log("Rule 19b");
+            let l = stack.pop();
+            stack.pop();
+            stack.push({ "type": LEX_LIST, "value": [l.value] });
+            return true;
+          }
+          if (is(stack.peek(), LEX_LB)) {
+            log("Rule 22");
+            stack.pop();
+            stack.push({ type: LEX_LIST, "value": [] });
+            return true;
+          }
+          if (is(stack.peek(), LEX_VALUE) && is(stack.last(1), LEX_LB)) {
+            log("Rule 23");
+            let val = stack.pop().value;
+            stack.pop();
+            stack.push({ type: LEX_LIST, "value": [val] });
+            return true;
+          }
+          if (is(stack.peek(), LEX_OBJ) && is(stack.last(1), LEX_LB)) {
+            log("Rule 23b");
+            let val = stack.pop();
+            stack.pop();
+            stack.push({ type: LEX_LIST, "value": [val] });
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_COMMA)) {
+            log("Error rule 5");
+            let l = stack.pop();
+            stack.push({ type: LEX_VALUE, "value": l.value });
+            log("Start subreduce... (" + l.value + ")");
+            while (reduce(stack))
+              ;
+            log("End subreduce");
+            stack.push({ type: LEX_RB });
+            return true;
+          }
+          if (is(stack.peek(), LEX_COMMA) && (is(stack.last(1), LEX_KEY) || is(stack.last(1), LEX_OBJ) || is(stack.last(1), LEX_VALUE))) {
+            log("Error rule 5a");
+            stack.pop();
+            stack.push({ type: LEX_RB, "value": "]" });
+            log("Start subreduce...");
+            log("Content: " + JSON.stringify(stack));
+            while (reduce(stack))
+              ;
+            log("End subreduce");
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_LB)) {
+            log("Error rule 5b");
+            let v = stack.pop();
+            stack.pop();
+            stack.push({ type: LEX_LIST, value: [v.value] });
+            return true;
+          }
+          if (is(stack.peek(), LEX_COMMA) && is(stack.last(1), LEX_VLIST)) {
+            log("Error rule 5c");
+            stack.pop();
+            stack.push({ type: LEX_RB });
+            log("Start subreduce...");
+            log("Content: " + JSON.stringify(stack));
+            while (reduce(stack))
+              ;
+            log("End subreduce");
+            return true;
+          }
+          break;
+        case LEX_RCB:
+          if (is(stack.peek(), LEX_KVLIST) && is(stack.last(1), LEX_LCB)) {
+            log("Rule 20");
+            let l = stack.pop();
+            stack.pop();
+            stack.push({ "type": LEX_OBJ, "value": l.value });
+            return true;
+          }
+          if (is(stack.peek(), LEX_LCB)) {
+            log("Rule 21");
+            stack.pop();
+            stack.push({ type: LEX_OBJ, "value": null });
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY) && is(stack.last(1), LEX_COLON)) {
+            log("Error rule 4a");
+            let l = stack.pop();
+            stack.push({ type: LEX_VALUE, "value": l.value });
+            log("Start subreduce... (" + l.value + ")");
+            while (reduce(stack))
+              ;
+            log("End subreduce");
+            stack.push({ type: LEX_RCB });
+            return true;
+          }
+          if (is(stack.peek(), LEX_COLON)) {
+            log("Error rule 4b");
+            stack.push({ type: LEX_VALUE, value: null });
+            log("Starting subreduce...");
+            while (reduce(stack))
+              ;
+            log("End subreduce.");
+            stack.push({ type: LEX_RCB });
+            return true;
+          }
+          if (is(stack.peek(), LEX_COMMA)) {
+            log("Error rule 10a");
+            stack.pop();
+            stack.push({ type: LEX_RCB });
+            return true;
+          }
+          throw new Error("Found } that I can't handle at line " + next.row + ":" + next.col);
+        case LEX_COMMA:
+          if (is(stack.peek(), LEX_COMMA)) {
+            log("Comma error rule 1");
+            return true;
+          }
+          if (is(stack.peek(), LEX_KEY)) {
+            log("Comma error rule 2");
+            const key = stack.pop();
+            stack.push({ type: LEX_VALUE, value: key.value });
+            log("Starting subreduce...");
+            while (reduce(stack))
+              ;
+            log("End subreduce.");
+            stack.push(next);
+            return true;
+          }
+          if (is(stack.peek(), LEX_COLON)) {
+            log("Comma error rule 3");
+            stack.push({ type: LEX_VALUE, value: null });
+            log("Starting subreduce...");
+            while (reduce(stack))
+              ;
+            log("End subreduce.");
+            stack.push(next);
+            return true;
+          }
+      }
+      stack.push(next);
+      return false;
+    }
+    function compileOST(tree, dupKeys) {
+      let rawTypes = ["boolean", "number", "string"];
+      if (rawTypes.indexOf(typeof tree) != -1)
+        return tree;
+      if (tree === null)
+        return null;
+      if (Array.isArray(tree)) {
+        let toR = [];
+        while (tree.length > 0)
+          toR.unshift(compileOST(tree.pop()));
+        return toR;
+      }
+      if (is(tree, LEX_OBJ)) {
+        let toR = {};
+        if (tree.value === null)
+          return {};
+        tree.value.forEach(function(i) {
+          const key = i.key;
+          const val = compileOST(i.value);
+          if (dupKeys && key in toR) {
+            toR[key] = {
+              "value": toR[key],
+              "next": val
+            };
+          } else {
+            toR[key] = val;
+          }
+        });
+        return toR;
+      }
+      if (is(tree, LEX_LIST)) {
+        return compileOST(tree.value);
+      }
+      return tree.value;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/dirty-json.js
+var require_dirty_json = __commonJS({
+  "../../node_modules/.pnpm/dirty-json@0.9.2/node_modules/dirty-json/dirty-json.js"(exports, module2) {
+    "use strict";
+    var parser = require_parser();
+    module2.exports.parse = parse;
+    function parse(text, config) {
+      let fallback = true;
+      let duplicateKeys = false;
+      if (config) {
+        if ("fallback" in config && config[fallback] === false) {
+          fallback = false;
+        }
+        duplicateKeys = "duplicateKeys" in config && config["duplicateKeys"] === true;
+      }
+      try {
+        return parser.parse(text, duplicateKeys);
+      } catch (e) {
+        if (fallback === false) {
+          throw e;
+        }
+        try {
+          let json = JSON.parse(text);
+          console.warn("dirty-json got valid JSON that failed with the custom parser. We're returning the valid JSON, but please file a bug report here: https://github.com/RyanMarcus/dirty-json/issues  -- the JSON that caused the failure was: " + text);
+          return json;
+        } catch (json_error) {
+          throw e;
+        }
+      }
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js
 function rng() {
   if (poolPtr > rnds8Pool.length - 16) {
@@ -763,7 +1803,7 @@ var require_priority_queue = __commonJS({
 });
 
 // ../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js
-var require_dist = __commonJS({
+var require_dist2 = __commonJS({
   "../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -1033,13 +2073,13 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/async_caller.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/async_caller.js
 var import_p_retry, import_p_queue, STATUS_NO_RETRY, STATUS_IGNORE, AsyncCaller;
 var init_async_caller = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/async_caller.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/async_caller.js"() {
     "use strict";
     import_p_retry = __toESM(require_p_retry());
-    import_p_queue = __toESM(require_dist());
+    import_p_queue = __toESM(require_dist2());
     STATUS_NO_RETRY = [
       400,
       // Bad Request
@@ -1158,7 +2198,7 @@ var init_async_caller = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/messages.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/messages.js
 function isLangChainMessage(message) {
   return typeof (message == null ? void 0 : message._getType) === "function";
 }
@@ -1173,25 +2213,25 @@ function convertLangChainMessageToExample(message) {
   return converted;
 }
 var init_messages = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/messages.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/messages.js"() {
     "use strict";
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/_uuid.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/_uuid.js
 function assertUuid(str) {
   if (!validate_default(str)) {
     throw new Error(`Invalid UUID: ${str}`);
   }
 }
 var init_uuid = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/_uuid.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/_uuid.js"() {
     "use strict";
     init_esm_node();
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/warn.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/warn.js
 function warnOnce(message) {
   if (!warnedMessages[message]) {
     console.warn(message);
@@ -1200,13 +2240,13 @@ function warnOnce(message) {
 }
 var warnedMessages;
 var init_warn = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/warn.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/warn.js"() {
     "use strict";
     warnedMessages = {};
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/client.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/client.js
 async function mergeRuntimeEnvIntoRunCreates(runs) {
   const runtimeEnv = await getRuntimeEnvironment();
   const envVars = getLangChainEnvVarsMetadata();
@@ -1244,7 +2284,7 @@ function trimQuotes(str) {
 }
 var getTracingSamplingRate, isLocalhost, raiseForStatus, handle429, Queue, DEFAULT_BATCH_SIZE_LIMIT_BYTES, Client;
 var init_client = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/client.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/client.js"() {
     "use strict";
     init_esm_node();
     init_async_caller();
@@ -3005,10 +4045,10 @@ var init_client = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/index.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/index.js
 var __version__;
 var init_dist = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/index.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/index.js"() {
     "use strict";
     init_client();
     init_run_trees();
@@ -3016,7 +4056,7 @@ var init_dist = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/env.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/env.js
 async function getRuntimeEnvironment() {
   if (runtimeEnvironment === void 0) {
     const env = getEnv();
@@ -3113,7 +4153,7 @@ function getShas() {
 }
 var globalEnv, isBrowser, isWebWorker, isJsDom, isDeno, isNode, getEnv, runtimeEnvironment, cachedCommitSHAs;
 var init_env = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/env.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/env.js"() {
     "use strict";
     init_dist();
     isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
@@ -3143,10 +4183,10 @@ var init_env = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/env.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/env.js
 var isTracingEnabled;
 var init_env2 = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/env.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/env.js"() {
     "use strict";
     init_env();
     isTracingEnabled = (tracingEnabled) => {
@@ -3164,7 +4204,7 @@ var init_env2 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/run_trees.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/run_trees.js
 function stripNonAlphanumeric(input) {
   return input.replace(/[-:.]/g, "");
 }
@@ -3188,7 +4228,7 @@ function isRunnableConfigLike(x) {
 }
 var Baggage, RunTree;
 var init_run_trees = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/run_trees.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/run_trees.js"() {
     "use strict";
     init_esm_node();
     init_env();
@@ -3612,13 +4652,13 @@ var init_run_trees = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/singletons/traceable.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/singletons/traceable.js
 function isTraceableFunction(x) {
   return typeof x === "function" && "langsmith:traceable" in x;
 }
 var MockAsyncLocalStorage, AsyncLocalStorageProvider, AsyncLocalStorageProviderSingleton, ROOT;
 var init_traceable = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/singletons/traceable.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/singletons/traceable.js"() {
     "use strict";
     MockAsyncLocalStorage = class {
       getStore() {
@@ -3658,7 +4698,7 @@ var init_traceable = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/asserts.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/asserts.js
 function isPromiseMethod(x) {
   if (x === "then" || x === "catch" || x === "finally") {
     return true;
@@ -3674,7 +4714,7 @@ function isKVMap(x) {
 }
 var isAsyncIterable, isIteratorLike, GeneratorFunction, isGenerator, isThenable, isReadableStream;
 var init_asserts = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/utils/asserts.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/utils/asserts.js"() {
     "use strict";
     isAsyncIterable = (x) => x != null && typeof x === "object" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
     typeof x[Symbol.asyncIterator] === "function";
@@ -3690,7 +4730,7 @@ var init_asserts = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/traceable.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/traceable.js
 function traceable(wrappedFunc, config) {
   const { aggregator, argsConfigPath, ...runTreeConfig } = config != null ? config : {};
   const traceableFunc = (...args) => {
@@ -3888,7 +4928,7 @@ function traceable(wrappedFunc, config) {
 }
 var import_node_async_hooks, handleRunInputs, handleRunOutputs, getTracingRunTree, getSerializablePromise, convertSerializableArg;
 var init_traceable2 = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/traceable.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/traceable.js"() {
     "use strict";
     import_node_async_hooks = require("async_hooks");
     init_run_trees();
@@ -4068,7 +5108,7 @@ var init_traceable2 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/wrappers/openai.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/wrappers/openai.js
 function _combineChatCompletionChoices(choices) {
   var _a, _b;
   const reversedChoices = choices.slice().reverse();
@@ -4142,7 +5182,7 @@ function _combineChatCompletionChoices(choices) {
 }
 var chatAggregator, textAggregator, wrapOpenAI, _wrapClient, wrapSDK;
 var init_openai = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/wrappers/openai.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/wrappers/openai.js"() {
     "use strict";
     init_traceable2();
     chatAggregator = (chunks) => {
@@ -4254,22 +5294,22 @@ var init_openai = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/wrappers/index.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/wrappers/index.js
 var init_wrappers = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/dist/wrappers/index.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/dist/wrappers/index.js"() {
     "use strict";
     init_openai();
   }
 });
 
-// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/wrappers.js
+// ../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/wrappers.js
 var wrappers_exports = {};
 __export(wrappers_exports, {
   wrapOpenAI: () => wrapOpenAI,
   wrapSDK: () => wrapSDK
 });
 var init_wrappers2 = __esm({
-  "../../node_modules/.pnpm/langsmith@0.1.36_openai@4.57.1_zod@3.23.8_/node_modules/langsmith/wrappers.js"() {
+  "../../node_modules/.pnpm/langsmith@0.1.36_@langchain+core@0.3.26_openai@4.57.1_zod@3.23.8___langchain@0.3.8_@langchain_hhfvzcdxxvt4fjst2j6ox4bwsa/node_modules/langsmith/wrappers.js"() {
     "use strict";
     init_wrappers();
   }
@@ -4295,7 +5335,7 @@ var import_node_assert3 = __toESM(require("assert"));
 var import_sdk = require("@anthropic-ai/sdk");
 var import_identity = require("@azure/identity");
 var import_utils = require("@midscene/shared/utils");
-var import_dirty_json = __toESM(require("dirty-json"));
+var import_dirty_json = __toESM(require_dirty_json());
 var import_openai2 = __toESM(require("openai"));
 var import_socks_proxy_agent = require("socks-proxy-agent");
 
@@ -4313,6 +5353,7 @@ var OPENAI_MAX_TOKENS = "OPENAI_MAX_TOKENS";
 var MIDSCENE_MODEL_TEXT_ONLY = "MIDSCENE_MODEL_TEXT_ONLY";
 var MIDSCENE_CACHE = "MIDSCENE_CACHE";
 var MATCH_BY_POSITION = "MATCH_BY_POSITION";
+var MIDSCENE_API_TYPE = "MIDSCENE-API-TYPE";
 var MIDSCENE_REPORT_TAG_NAME = "MIDSCENE_REPORT_TAG_NAME";
 var MIDSCENE_USE_AZURE_OPENAI = "MIDSCENE_USE_AZURE_OPENAI";
 var MIDSCENE_AZURE_OPENAI_SCOPE = "MIDSCENE_AZURE_OPENAI_SCOPE";
@@ -4375,8 +5416,7 @@ var getAIConfigInJson = (configKey) => {
 
 // src/ai-model/common.ts
 var import_node_assert = __toESM(require("assert"));
-async function callAiFn(options) {
-  const { msgs, AIActionType: AIActionTypeValue } = options;
+async function callAiFn(msgs, AIActionTypeValue) {
   (0, import_node_assert.default)(
     checkAIConfig(),
     "Cannot find config for AI model service. You should set it before using. https://midscenejs.com/model-provider.html"
@@ -4387,19 +5427,9 @@ async function callAiFn(options) {
   );
   return { content, usage };
 }
-function transformUserMessages(msgs) {
-  const textOnly = Boolean(getAIConfig(MIDSCENE_MODEL_TEXT_ONLY));
-  if (!textOnly)
-    return msgs;
-  return msgs.reduce((res, msg) => {
-    if (msg.type === "text") {
-      res += msg.text;
-    }
-    return res;
-  }, "");
-}
 
 // src/ai-model/prompt/element_inspector.ts
+var import_prompts = require("@langchain/core/prompts");
 function systemPromptToFindElement() {
   if (getAIConfig(MATCH_BY_POSITION)) {
     return systemPromptToFindElementPosition();
@@ -4542,36 +5572,31 @@ Output Example:
 }
 function systemPromptToFindElementPosition() {
   return `
-    ## Role:
-    You are an expert in software page image (2D) and page element text analysis.
+You are a GUI agent. You are given a task and your action history, with screenshots. You need to perform the next action to complete the task.
 
-    ## Objective:
-    Based on screenshots and descriptions, find specific coordinates
+## Output Format
+\`\`\`
+Action_Summary: ...
+Action: ...
+\`\`\`
 
-    ## Output Format:
+## Action Space
+click(start_box='[x1, y1, x2, y2]')
+long_press(start_box='[x1, y1, x2, y2]', time='')
+type(content='')
+scroll(direction='down or up or right or left')
+open_app(app_name='')
+navigate_back()
+navigate_home()
+WAIT()
+finished() # Submit the task regardless of whether it succeeds or fails.
 
-    Please return the result in JSON format as follows:
+## Note
+- Use Chinese in \`Action_Summary\` part.
 
-    \`\`\`json
-    {
-      "elements": [
-        {
-          // Describe the reason for finding this element, replace with actual value in practice
-          "reason": "Reason for finding element 4: It is located in the upper right corner, is an image type, and according to the screenshot, it is a shopping cart icon button",
-          // If the target element includes text information, extract the text information; if it does not, do not extract it
-          "text": "",
-          // position of this element
-          "position": { x: number, y: number }
-        }
-    ],
-    "errors": []// Return an error if there is no target element on the picture
-    }
-    \`\`\`
+## User Instruction
   `;
 }
-function multiDescription(multi) {
-  return multi ? "multiple elements matching the description (two or more)" : "The element closest to the description (only one)";
-}
 var findElementSchema = {
   type: "json_schema",
   json_schema: {
@@ -4616,6 +5641,23 @@ var findElementSchema = {
     }
   }
 };
+var findElementPrompt = new import_prompts.PromptTemplate({
+  template: `
+    Here is the item user want to find. Just go ahead:
+    =====================================
+    {{
+      "description": "{targetElementDescription}",
+      "multi": {multi}
+    }}
+    =====================================
+
+    pageDescription: {pageDescription}
+  `,
+  inputVariables: ["pageDescription", "targetElementDescription", "multi"]
+});
+
+// src/ai-model/prompt/planning.ts
+var import_prompts3 = require("@langchain/core/prompts");
 
 // src/ai-model/prompt/util.ts
 var import_node_assert2 = __toESM(require("assert"));
@@ -4624,6 +5666,7 @@ var import_node_assert2 = __toESM(require("assert"));
 var import_img = require("@midscene/shared/img");
 
 // src/ai-model/prompt/util.ts
+var import_prompts2 = require("@langchain/core/prompts");
 var characteristic = "You are a versatile professional in software UI design and testing. Your outstanding contributions will impact the user experience of billions of users.";
 var contextFormatIntro = `
 The user will give you a screenshot and some of the texts on it. There may be some none-English characters (like Chinese) on it, indicating it's an non-English app. If some text is shown on screenshot but not introduced by the JSON description, use the information you see on screenshot.`;
@@ -4652,6 +5695,22 @@ Return in the following JSON format:
 }
 `;
 }
+var extractDataPrompt = new import_prompts2.PromptTemplate({
+  template: `
+pageDescription: {pageDescription}
+
+Use your extract_data_from_UI skill to find the following data, placing it in the \`data\` field
+DATA_DEMAND start:
+=====================================
+{dataKeys}
+
+{dataQuery}
+
+=====================================
+DATA_DEMAND ends.
+  `,
+  inputVariables: ["pageDescription", "dataKeys", "dataQuery"]
+});
 function systemPromptToAssert() {
   return `
 ${characteristic}
@@ -4700,7 +5759,7 @@ function truncateText(text, maxLength = 100) {
   }
   return "";
 }
-function elementByPosition(elementsInfo, position) {
+function elementByPositionWithElementInfo(elementsInfo, position) {
   (0, import_node_assert2.default)(typeof position !== "undefined", "position is required for query");
   const item = elementsInfo.find((item2) => {
     return item2.rect.left <= position.x && position.x <= item2.rect.left + item2.rect.width && item2.rect.top <= position.y && position.y <= item2.rect.top + item2.rect.height;
@@ -4754,23 +5813,23 @@ async function describeUserPage(context, opt) {
     const { id, ...rest } = item;
     return `id=${id}: ${JSON.stringify(rest)}`;
   }).join("\n\n");
+  const pageJSONDescription = getAIConfig(MATCH_BY_POSITION) ? "" : `Some of the elements are marked with a rectangle in the screenshot, some are not. 
+ Json description of all the page elements:
+${contentList}`;
+  const sizeDescription = describeSize({ width, height });
   return {
-    description: `
-The size of the page: ${describeSize({ width, height })}
-Some of the elements are marked with a rectangle in the screenshot, some are not.
-
-${// if match by id, use the description of the element
-    getAIConfig(MATCH_BY_POSITION) ? "" : `Json description of all the page elements:
-${contentList}`}
-`,
+    description: `The size of the page: ${sizeDescription} 
+ ${pageJSONDescription}`,
     elementById(id) {
       (0, import_node_assert2.default)(typeof id !== "undefined", "id is required for query");
       const item = idElementMap[`${id}`];
       return item;
     },
-    elementByPosition(position) {
-      return elementByPosition(elementsInfo, position);
-    }
+    elementByPosition(position, size) {
+      console.log("elementByPosition", { position, size });
+      return elementByPositionWithElementInfo(elementsInfo, position);
+    },
+    size: { width, height }
   };
 }
 function cropFieldInformation(elementsInfo, truncateTextLength, filterNonTextContent = false) {
@@ -4824,19 +5883,35 @@ function cropFieldInformation(elementsInfo, truncateTextLength, filterNonTextCon
 // src/ai-model/prompt/planning.ts
 var quickAnswerFormat = () => {
   const matchByPosition = getAIConfig(MATCH_BY_POSITION);
-  const description = `
-  ${matchByPosition ? `"position": { x: number; y: number } // Represents the position of the element; replace with actual values in practice (ensure it reflects the element's position)` : '"id": string // Represents the ID of the element; replace with actual values in practice'}
-  `;
-  const format = matchByPosition ? '"position": { x: number; y: number }' : '"id": string';
-  const sample = matchByPosition ? '{"position": { x: 100, y: 200 }}' : '{"id": "c81c4e9a33"}';
+  const locationFormat = {
+    position: {
+      description: `"position": { x: number; y: number } // Represents the position of the element; replace with actual values in practice (ensure it reflects the element's position)`,
+      format: '"position": { x: number; y: number }',
+      sample: '{"prompt": "the search bar" // Use language consistent with the information on the page}',
+      locateParam: `{
+        "prompt"?: string // the description of the element to find. It can only be omitted when locate is null.
+      } | null // If it's not on the page, the LocateParam should be null`
+    },
+    id: {
+      description: '"id": string // Represents the ID of the element; replace with actual values in practice',
+      format: '"id": string',
+      sample: `{"id": "c81c4e9a33", "prompt": "the search bar"}`,
+      locateParam: `{
+        "id": string, // the id of the element found. It should either be the id marked with a rectangle in the screenshot or the id described in the description.
+        "prompt"?: string // the description of the element to find. It can only be omitted when locate is null.
+      } | null // If it's not on the page, the LocateParam should be null`
+    }
+  };
+  const type = matchByPosition ? "position" : "id";
+  const format = locationFormat[type];
   return {
-    description,
-    format,
-    sample
+    description: format.description,
+    format: format.format,
+    sample: format.sample,
+    locateParam: format.locateParam
   };
 };
-function systemPromptToTaskPlanning() {
-  return `
+var systemTemplate = `
 ## Role
 
 You are a versatile professional in software UI automation. Your outstanding contributions will impact the user experience of billions of users.
@@ -4870,76 +5945,70 @@ You are a versatile professional in software UI automation. Your outstanding con
 
 The \`locate\` param is commonly used in the \`param\` field of the action, means to locate the target element to perform the action, it follows the following scheme:
 
-type LocateParam = {
-  "id": string, // the id of the element found. It should either be the id marked with a rectangle in the screenshot or the id described in the description.
-  prompt?: string // the description of the element to find. It can only be omitted when locate is null.
-} | null // If it's not on the page, the LocateParam should be null
+type LocateParam = {locateParam}
 
 ### Supported actions
 
 Each action has a \`type\` and corresponding \`param\`. To be detailed:
 - type: 'Tap', tap the located element
-  * { locate: LocateParam, param: null }
+  * {{ locate: {sample}, param: null }}
 - type: 'Hover', move mouse over to the located element
-  * { locate: LocateParam, param: null }
+  * {{ locate: LocateParam, param: null }}
 - type: 'Input', replace the value in the input field
-  * { locate: LocateParam, param: { value: string } }
+  * {{ locate: LocateParam, param: {{ value: string }} }}
   * \`value\` is the final required input value based on the existing input. No matter what modifications are required, just provide the final value to replace the existing input value. 
 - type: 'KeyboardPress', press a key
-  * { param: { value: string } }
+  * {{ param: {{ value: string }} }}
 - type: 'Scroll', scroll up or down.
-  * { 
+  * {{ 
       locate: LocateParam | null, 
-      param: { 
+      param: {{ 
         direction: 'down'(default) | 'up' | 'right' | 'left', 
         scrollType: 'once' (default) | 'untilBottom' | 'untilTop' | 'untilRight' | 'untilLeft', 
         distance: null | number 
-      } 
-    }
+      }} 
+    }}
     * To scroll some specific element, put the element at the center of the region in the \`locate\` field. If it's a page scroll, put \`null\` in the \`locate\` field. 
     * \`param\` is required in this action. If some fields are not specified, use direction \`down\`, \`once\` scroll type, and \`null\` distance.
 - type: 'FalsyConditionStatement'
-  * { param: null }
+  * {{ param: null }}
   * use this action when the instruction is an "if" statement and the condition is falsy.
 - type: 'Sleep'
-  * { param: { timeMs: number } }
+  * {{ param: {{ timeMs: number }} }}
 
 ## How to compose the \`taskWillBeAccomplished\` and \`furtherPlan\` fields ?
 
 \`taskWillBeAccomplished\` is a boolean field, means whether the task will be accomplished after all the actions.
 
-\`furtherPlan\` is used when the task cannot be accomplished. It follows the scheme { whatHaveDone: string, whatToDoNext: string }:
+\`furtherPlan\` is used when the task cannot be accomplished. It follows the scheme {{ whatHaveDone: string, whatToDoNext: string }}:
 - \`whatHaveDone\`: a string, describe what have been done after the previous actions.
 - \`whatToDoNext\`: a string, describe what should be done next after the previous actions has finished. It should be a concise and clear description of the actions to be performed. Make sure you don't lose any necessary steps user asked.
-
+`;
+var outputTemplate = `
 ## Output JSON Format:
 
 The JSON format is as follows:
 
-{
+{{
   "actions": [
-    {
+    {{
       "thought": "Reasons for generating this task, and why this task is feasible on this page",
       "type": "Tap",
       "param": null,
-      "locate": {
-        {"id": "c81c4e9a33"},
-        prompt: "the search bar"
-      } | null,
-    },
+      "locate": {sample} | null,
+    }},
     // ... more actions
   ],
   "taskWillBeAccomplished": boolean,
-  "furtherPlan": { "whatHaveDone": string, "whatToDoNext": string } | null,
+  "furtherPlan": {{ "whatHaveDone": string, "whatToDoNext": string }} | null,
   "error"?: string
-}
-
-## Example #1 : How to decompose a task
+}}
+Here is an example of how to decompose a task:
 
 When a user says 'Click the language switch button, wait 1s, click "English"', the user will give you the description like this:
 
 ====================
-${samplePageDescription}
+{pageDescription}
 ====================
 
 By viewing the page screenshot and description, you should consider this and output the JSON:
@@ -4949,110 +6018,119 @@ By viewing the page screenshot and description, you should consider this and out
 * The "English" option button is not shown in the screenshot now, it means it may only show after the previous actions are finished. So the last action will have a \`null\` value in the \`locate\` field. 
 * The task cannot be accomplished (because we cannot see the "English" option now), so a \`furtherPlan\` field is needed.
 
-{
+{{
   "actions":[
-    {
+    {{
+      "type": "Tap", 
       "thought": "Click the language switch button to open the language options.",
-      "type": "Tap",
       "param": null,
-      "locate": {
-        ${quickAnswerFormat().sample},
-        "prompt": "the language switch button with the text '中文'"
-      }
-    },
-    {
-      "thought": "Wait for 1 second to ensure the language options are displayed.",
+      "locate": {sample},
+    }},
+    {{
       "type": "Sleep",
-      "param": { "timeMs": 1000 },
-    },
-    {
-      "thought": "Locate the 'English' option in the language menu.", 
+      "thought": "Wait for 1 second to ensure the language options are displayed.",
+      "param": {{ "timeMs": 1000 }},
+    }},
+    {{
       "type": "Tap",
-      "param": null,
+      "thought": "Locate the 'English' option in the language menu.",
+      "param": null, 
       "locate": null
-    },
+    }},
   ],
   "error": null,
   "taskWillBeAccomplished": false,
-  "furtherPlan": { 
-    "whatToDoNext": "find the 'English' option and click on it", 
-    "whatHaveDone": "Click the language switch button and wait 1s" 
-  }
-}
+  "furtherPlan": {{
+    "whatToDoNext": "find the 'English' option and click on it",
+    "whatHaveDone": "Click the language switch button and wait 1s"
+  }}
+}}
 
-## Example #2 : Tolerate the error situation only when the instruction is an "if" statement
+Here is another example of how to tolerate error situations only when the instruction is an "if" statement:
 
 If the user says "If there is a popup, close it", you should consider this and output the JSON:
 
 * By viewing the page screenshot and description, you cannot find the popup, so the condition is falsy.
 * The instruction itself is an "if" statement, it means the user can tolerate this situation, so you should leave a \`FalsyConditionStatement\` action.
 
-{
-  "actions": [{
-      "thought": "There is no popup on the page",
+{{
+  "actions": [{{
       "type": "FalsyConditionStatement",
+      "thought": "There is no popup on the page",
       "param": null
-    }
+    }}
   ],
   "taskWillBeAccomplished": true,
   "furtherPlan": null
-}
+}}
 
 For contrast, if the user says "Close the popup" in this situation, you should consider this and output the JSON:
 
-{
+{{
   "actions": [],
   "error": "The instruction and page context are irrelevant, there is no popup on the page",
   "taskWillBeAccomplished": true,
   "furtherPlan": null
-}
+}}
 
-## Example #3 : When task is accomplished, don't plan more actions
+Here is an example of when task is accomplished, don't plan more actions:
 
 When the user ask to "Wait 4s", you should consider this:
 
-{
+{{
   "actions": [
-    {
-      "thought": "Wait for 4 seconds",
+    {{
       "type": "Sleep",
-      "param": { "timeMs": 4000 },
-    },
+      "thought": "Wait for 4 seconds",
+      "param": {{ "timeMs": 4000 }},
+    }},
   ],
   "taskWillBeAccomplished": true,
   "furtherPlan": null // All steps have been included in the actions, so no further plan is needed
-}
+}}
 
-## Bad case #1 : Missing \`prompt\` in the 'Locate' field; Missing \`furtherPlan\` field when the task won't be accomplished
+Here is an example of what NOT to do:
 
 Wrong output:
 
-{
+{{
   "actions":[
-    {
-      "thought": "Click the language switch button to open the language options.",
+    {{
       "type": "Tap",
+      "thought": "Click the language switch button to open the language options.",
       "param": null,
-      "locate": {
-        ${quickAnswerFormat().sample}, // WRONG:prompt is missing
-      }
-    },
-    {
+      "locate": {{
+        {sample}, // WRONG:prompt is missing
+      }}
+    }},
+    {{
+      "type": "Tap", 
       "thought": "Click the English option",
-      "type": "Tap",
       "param": null,
       "locate": null, // This means the 'English' option is not shown in the screenshot, the task cannot be accomplished
-    }
+    }}
   ],
   "taskWillBeAccomplished": false,
   // WRONG: should not be null
   "furtherPlan": null,
-}
+}}
 
-Reason: 
+Reason:
 * The \`prompt\` is missing in the first 'Locate' action
 * Since the option button is not shown in the screenshot, the task cannot be accomplished, so a \`furtherPlan\` field is needed.
 `;
+async function systemPromptToTaskPlanning() {
+  const promptTemplate = new import_prompts3.PromptTemplate({
+    template: `${systemTemplate}
+
+${outputTemplate}`,
+    inputVariables: ["pageDescription", "sample", "locateParam"]
+  });
+  return await promptTemplate.format({
+    pageDescription: samplePageDescription,
+    sample: quickAnswerFormat().sample,
+    locateParam: quickAnswerFormat().locateParam
+  });
 }
 var planSchema = {
   type: "json_schema",
@@ -5136,6 +6214,35 @@ var planSchema = {
     }
   }
 };
+var generateTaskBackgroundContext = (userPrompt, originalPrompt, whatHaveDone) => {
+  if (originalPrompt && whatHaveDone) {
+    return `
+    For your information, this is a task that some important person handed to you. Here is the original task description and what have been done after the previous actions:
+    =====================================
+    Original task description: ${originalPrompt}
+    =====================================
+    What have been done: ${whatHaveDone}
+    =====================================
+    `;
+  }
+  return `
+  Here is the instruction:
+  =====================================
+  ${userPrompt}
+  =====================================
+  `;
+};
+var automationUserPrompt = new import_prompts3.PromptTemplate({
+  template: `
+    pageDescription:
+    =====================================
+    {pageDescription}
+    =====================================
+
+    {taskBackgroundContext}
+  `,
+  inputVariables: ["pageDescription", "taskBackgroundContext"]
+});
 
 // src/ai-model/openai/index.ts
 function checkAIConfig(preferVendor) {
@@ -5158,7 +6265,9 @@ function getModelName() {
   }
   return modelName;
 }
-async function createChatClient() {
+async function createChatClient({
+  AIActionTypeValue
+}) {
   let openai;
   const extraConfig = getAIConfigInJson(MIDSCENE_OPENAI_INIT_CONFIG_JSON);
   const socksProxy = getAIConfig(MIDSCENE_OPENAI_SOCKS_PROXY);
@@ -5199,6 +6308,7 @@ async function createChatClient() {
         endpoint: getAIConfig(AZURE_OPENAI_ENDPOINT),
         apiVersion: getAIConfig(AZURE_OPENAI_API_VERSION),
         deployment: getAIConfig(AZURE_OPENAI_DEPLOYMENT),
+        dangerouslyAllowBrowser: true,
         ...extraConfig,
         ...extraAzureConfig
       });
@@ -5209,6 +6319,10 @@ async function createChatClient() {
       apiKey: getAIConfig(OPENAI_API_KEY),
       httpAgent: socksAgent,
       ...extraConfig,
+      defaultHeaders: {
+        ...(extraConfig == null ? void 0 : extraConfig.defaultHeaders) || {},
+        [MIDSCENE_API_TYPE]: AIActionTypeValue.toString()
+      },
       dangerouslyAllowBrowser: true
     });
   }
@@ -5241,8 +6355,10 @@ async function createChatClient() {
   }
   throw new Error("Openai SDK or Anthropic SDK is not initialized");
 }
-async function call(messages, responseFormat) {
-  const { completion, style } = await createChatClient();
+async function call(messages, AIActionTypeValue, responseFormat) {
+  const { completion, style } = await createChatClient({
+    AIActionTypeValue
+  });
   const shouldPrintTiming = typeof getAIConfig(MIDSCENE_DEBUG_AI_PROFILE) === "string";
   const maxTokens = getAIConfig(OPENAI_MAX_TOKENS);
   const startTime = Date.now();
@@ -5325,47 +6441,47 @@ async function callToGetJSONObject(messages, AIActionTypeValue) {
       responseFormat = { type: "json_object" /* JSON */ };
     }
   }
-  const safeJsonParse = (input) => {
-    try {
-      return JSON.parse(input);
-    } catch (e) {
-      return null;
-    }
-  };
-  const response = await call(messages, responseFormat);
+  const response = await call(messages, AIActionTypeValue, responseFormat);
   (0, import_node_assert3.default)(response, "empty response");
-  let jsonContent = safeJsonParse(response.content);
-  if (jsonContent)
-    return { content: jsonContent, usage: response.usage };
-  const cleanJsonString = extractJSONFromCodeBlock(response.content);
-  try {
-    jsonContent = JSON.parse(cleanJsonString);
-  } catch (e) {
-  }
-  if (jsonContent)
-    return { content: jsonContent, usage: response.usage };
+  const jsonContent = safeParseJson(response.content);
+  return { content: jsonContent, usage: response.usage };
+}
+function extractJSONFromCodeBlock(response) {
   try {
-    jsonContent = import_dirty_json.default.parse(cleanJsonString);
+    const jsonMatch = response.match(/^\s*(\{[\s\S]*\})\s*$/);
+    if (jsonMatch) {
+      return jsonMatch[1];
+    }
+    const codeBlockMatch = response.match(
+      /```(?:json)?\s*(\{[\s\S]*?\})\s*```/
+    );
+    if (codeBlockMatch) {
+      return codeBlockMatch[1];
+    }
+    const jsonLikeMatch = response.match(/\{[\s\S]*\}/);
+    if (jsonLikeMatch) {
+      return jsonLikeMatch[0];
+    }
   } catch (e) {
   }
-  if (jsonContent)
-    return { content: jsonContent, usage: response.usage };
-  throw Error(`failed to parse json response: ${response.content}`);
+  return response;
 }
-function extractJSONFromCodeBlock(response) {
-  const jsonMatch = response.match(/^\s*(\{[\s\S]*\})\s*$/);
-  if (jsonMatch) {
-    return jsonMatch[1];
+function safeParseJson(input) {
+  var _a;
+  const cleanJsonString = extractJSONFromCodeBlock(input);
+  if (cleanJsonString.match(/\((\d+),(\d+)\)/)) {
+    return (_a = cleanJsonString.match(/\((\d+),(\d+)\)/)) == null ? void 0 : _a.slice(1).map(Number);
   }
-  const codeBlockMatch = response.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
-  if (codeBlockMatch) {
-    return codeBlockMatch[1];
+  try {
+    return JSON.parse(cleanJsonString);
+  } catch (e) {
   }
-  const jsonLikeMatch = response.match(/\{[\s\S]*\}/);
-  if (jsonLikeMatch) {
-    return jsonLikeMatch[0];
+  try {
+    return import_dirty_json.default.parse(cleanJsonString);
+  } catch (e) {
+    console.log("e:", e);
   }
-  return response;
+  throw Error(`failed to parse json response: ${input}`);
 }
 
 // src/ai-model/inspect.ts
@@ -5374,76 +6490,82 @@ var liteContextConfig = {
   filterNonTextContent: true,
   truncateTextLength: 200
 };
-function transformElementPositionToId(aiResult, elementsInfo) {
+function transformToAbsoluteCoords(relativePosition, size) {
+  return {
+    x: Number((relativePosition.x / 1e3 * size.width).toFixed(3)),
+    y: Number((relativePosition.y / 1e3 * size.height).toFixed(3))
+  };
+}
+async function transformElementPositionToId(aiResult, elementsInfo, size, screenshotBase64) {
+  if (Array.isArray(aiResult)) {
+    const relativePosition = aiResult;
+    const absolutePosition = transformToAbsoluteCoords(
+      {
+        x: relativePosition[0],
+        y: relativePosition[1]
+      },
+      size
+    );
+    const element = elementByPositionWithElementInfo(
+      elementsInfo,
+      absolutePosition
+    );
+    (0, import_node_assert4.default)(
+      element,
+      `inspect: no id found with position: ${JSON.stringify({ absolutePosition })}`
+    );
+    return {
+      errors: [],
+      elements: [
+        {
+          id: element.id
+        }
+      ]
+    };
+  }
   return {
     errors: aiResult.errors,
-    elements: aiResult.elements.map((item) => {
-      var _a;
-      if ("id" in item) {
-        return item;
-      }
-      const { position } = item;
-      const id = (_a = elementByPosition(elementsInfo, position)) == null ? void 0 : _a.id;
-      (0, import_node_assert4.default)(
-        id,
-        `inspect: no id found with position: ${JSON.stringify({ position })}`
-      );
-      return {
-        ...item,
-        id
-      };
-    })
+    elements: aiResult.elements
   };
 }
+function getQuickAnswer(quickAnswer, elementById) {
+  if (!quickAnswer) {
+    return void 0;
+  }
+  if ("id" in quickAnswer && quickAnswer.id && elementById(quickAnswer.id)) {
+    return {
+      parseResult: {
+        elements: [quickAnswer],
+        errors: []
+      },
+      rawResponse: quickAnswer,
+      elementById
+    };
+  }
+}
 async function AiInspectElement(options) {
   const { context, multi, targetElementDescription, callAI } = options;
   const { screenshotBase64, screenshotBase64WithElementMarker } = context;
-  const { description, elementById, elementByPosition: elementByPosition2 } = await describeUserPage(context);
-  if (options.quickAnswer) {
-    if ("id" in options.quickAnswer) {
-      if (elementById(options.quickAnswer.id)) {
-        return {
-          parseResult: {
-            elements: [options.quickAnswer],
-            errors: []
-          },
-          elementById
-        };
-      }
-      if (!targetElementDescription) {
-        return {
-          parseResult: {
-            elements: [],
-            errors: [
-              `inspect: cannot find the target by id: ${options.quickAnswer.id}, and no target element description is provided`
-            ]
-          },
-          elementById
-        };
-      }
-    }
-    if ("position" in options.quickAnswer && elementByPosition2(options.quickAnswer.position)) {
-      return {
-        parseResult: transformElementPositionToId(
-          {
-            elements: [options.quickAnswer]
-          },
-          context.content
-        ),
-        elementById
-      };
-    }
+  const { description, elementById, elementByPosition, size } = await describeUserPage(context);
+  const quickAnswer = getQuickAnswer(options.quickAnswer, elementById);
+  if (quickAnswer) {
+    return quickAnswer;
   }
   (0, import_node_assert4.default)(
     targetElementDescription,
     "cannot find the target element description"
   );
+  const userInstructionPrompt = await findElementPrompt.format({
+    pageDescription: description,
+    targetElementDescription,
+    multi
+  });
   const systemPrompt = systemPromptToFindElement();
   const msgs = [
     { role: "system", content: systemPrompt },
     {
       role: "user",
-      content: transformUserMessages([
+      content: [
         {
           type: "image_url",
           image_url: {
@@ -5452,46 +6574,23 @@ async function AiInspectElement(options) {
         },
         {
           type: "text",
-          text: `
-pageDescription: 
-
-${description}
-
-Here is the item user want to find. Just go ahead:
-=====================================
-${JSON.stringify({
-            description: targetElementDescription,
-            multi: multiDescription(multi)
-          })}
-=====================================`
+          text: userInstructionPrompt
         }
-      ])
+      ]
     }
   ];
-  if (callAI) {
-    const res = await callAI({
-      msgs,
-      AIActionType: 1 /* INSPECT_ELEMENT */
-    });
-    return {
-      parseResult: transformElementPositionToId(res.content, context.content),
-      rawResponse: res,
-      elementById,
-      usage: res.usage
-    };
-  }
-  const inspectElement = await callAiFn({
-    msgs,
-    AIActionType: 1 /* INSPECT_ELEMENT */
-  });
+  const callAIFn = callAI || callToGetJSONObject;
+  const res = await callAIFn(msgs, 1 /* INSPECT_ELEMENT */);
   return {
-    parseResult: transformElementPositionToId(
-      inspectElement.content,
-      context.content
+    parseResult: await transformElementPositionToId(
+      res.content,
+      context.content,
+      size,
+      screenshotBase64
     ),
-    rawResponse: inspectElement,
+    rawResponse: res.content,
     elementById,
-    usage: inspectElement.usage
+    usage: res.usage
   };
 }
 async function AiExtractElementInfo(options) {
@@ -5502,11 +6601,25 @@ async function AiExtractElementInfo(options) {
     context,
     liteContextConfig
   );
+  let dataKeys = "";
+  let dataQueryText = "";
+  if (typeof dataQuery === "string") {
+    dataKeys = "";
+    dataQueryText = dataQuery;
+  } else {
+    dataKeys = `return in key-value style object, keys are ${Object.keys(dataQuery).join(",")}`;
+    dataQueryText = JSON.stringify(dataQuery, null, 2);
+  }
+  const extractDataPromptText = await extractDataPrompt.format({
+    pageDescription: description,
+    dataKeys,
+    dataQuery: dataQueryText
+  });
   const msgs = [
     { role: "system", content: systemPrompt },
     {
       role: "user",
-      content: transformUserMessages([
+      content: [
         {
           type: "image_url",
           image_url: {
@@ -5515,25 +6628,15 @@ async function AiExtractElementInfo(options) {
         },
         {
           type: "text",
-          text: `
-pageDescription: ${description}
-
-Use your extract_data_from_UI skill to find the following data, placing it in the \`data\` field
-DATA_DEMAND start:
-=====================================
-${typeof dataQuery === "object" ? `return in key-value style object, keys are ${Object.keys(dataQuery).join(",")}` : ""}
-${typeof dataQuery === "string" ? dataQuery : JSON.stringify(dataQuery, null, 2)}
-=====================================
-DATA_DEMAND ends.
-          `
+          text: extractDataPromptText
         }
-      ])
+      ]
     }
   ];
-  const result = await callAiFn({
+  const result = await callAiFn(
     msgs,
-    AIActionType: 2 /* EXTRACT_DATA */
-  });
+    2 /* EXTRACT_DATA */
+  );
   return {
     parseResult: result.content,
     elementById,
@@ -5550,7 +6653,7 @@ async function AiAssert(options) {
     { role: "system", content: systemPrompt },
     {
       role: "user",
-      content: transformUserMessages([
+      content: [
         {
           type: "image_url",
           image_url: {
@@ -5569,43 +6672,40 @@ async function AiAssert(options) {
     =====================================
   `
         }
-      ])
+      ]
     }
   ];
-  const { content: assertResult, usage } = await callAiFn({
+  const { content: assertResult, usage } = await callAiFn(
     msgs,
-    AIActionType: 0 /* ASSERT */
-  });
+    0 /* ASSERT */
+  );
   return {
     content: assertResult,
     usage
   };
 }
 
-// src/ai-model/automation/index.ts
+// src/ai-model/automation.ts
 var import_node_assert5 = __toESM(require("assert"));
 async function plan(userPrompt, opts) {
   const { callAI, context } = opts || {};
   const { screenshotBase64, screenshotBase64WithElementMarker } = context;
-  const { description: pageDescription, elementByPosition: elementByPosition2 } = await describeUserPage(context);
-  const systemPrompt = systemPromptToTaskPlanning();
-  let taskBackgroundContext = "";
-  if (opts.originalPrompt && opts.whatHaveDone) {
-    taskBackgroundContext = `For your information, this is a task that some important person handed to you. Here is the original task description and what have been done after the previous actions:
-=====================================
-Original task description:
-${opts.originalPrompt}
-=====================================
-What have been done:
-${opts.whatHaveDone}
-=====================================
-`;
-  }
+  const { description: pageDescription, elementByPosition } = await describeUserPage(context);
+  const systemPrompt = await systemPromptToTaskPlanning();
+  const taskBackgroundContextText = generateTaskBackgroundContext(
+    userPrompt,
+    opts.originalPrompt,
+    opts.whatHaveDone
+  );
+  const userInstructionPrompt = await automationUserPrompt.format({
+    pageDescription,
+    taskBackgroundContext: taskBackgroundContextText
+  });
   const msgs = [
     { role: "system", content: systemPrompt },
     {
       role: "user",
-      content: transformUserMessages([
+      content: [
         {
           type: "image_url",
           image_url: {
@@ -5615,28 +6715,13 @@ ${opts.whatHaveDone}
         },
         {
           type: "text",
-          text: `
-pageDescription:
- 
-${pageDescription}
-
-
-Here is the instruction:
-=====================================
-${userPrompt}
-=====================================
-
-${taskBackgroundContext}
-`.trim()
+          text: userInstructionPrompt
         }
-      ])
+      ]
     }
   ];
-  const call2 = callAI || callAiFn;
-  const { content, usage } = await call2({
-    msgs,
-    AIActionType: 3 /* PLAN */
-  });
+  const call3 = callAI || callAiFn;
+  const { content, usage } = await call3(msgs, 3 /* PLAN */);
   const planFromAI = content;
   const actions = (planFromAI == null ? void 0 : planFromAI.actions) || [];
   (0, import_node_assert5.default)(planFromAI, "can't get plans from AI");
@@ -5658,3 +6743,11 @@ ${taskBackgroundContext}
   systemPromptToFindElement,
   transformElementPositionToId
 });
+/*! Bundled license information:
+
+string.fromcodepoint/fromcodepoint.js:
+  (*! http://mths.be/fromcodepoint v0.2.1 by @mathias *)
+
+utf8/utf8.js:
+  (*! https://mths.be/utf8js v3.0.0 by @mathias *)
+*/