@midscene/core 0.1.0 → 0.1.1

package/dist/lib/ai-model.js

@@ -1,12 +1,19 @@
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -17,63 +24,4238 @@ var __spreadValues = (a, b) => {
       if (__propIsEnum.call(b, prop))
         __defNormalProp(a, prop, b[prop]);
     }
-  return a;
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise;
+  this[1] = isYieldStar;
+};
+var __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  };
+  var method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no));
+  var it = {};
+  return generator = generator.apply(__this, __arguments), it[Symbol.asyncIterator] = () => it, method("next"), method("throw"), method("return"), it;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")];
+  var isAwait = false;
+  var method;
+  var it = {};
+  if (obj == null) {
+    obj = value[__knownSymbol("iterator")]();
+    method = (k) => it[k] = (x) => obj[k](x);
+  } else {
+    obj = obj.call(value);
+    method = (k) => it[k] = (v) => {
+      if (isAwait) {
+        isAwait = false;
+        if (k === "throw")
+          throw v;
+        return v;
+      }
+      isAwait = true;
+      return {
+        done: false,
+        value: new __await(new Promise((resolve) => {
+          var x = obj[k](v);
+          if (!(x instanceof Object))
+            throw TypeError("Object expected");
+          resolve(x);
+        }), 1)
+      };
+    };
+  }
+  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js
+var require_retry_operation = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js"(exports, module2) {
+    "use strict";
+    function RetryOperation(timeouts, options) {
+      if (typeof options === "boolean") {
+        options = { forever: options };
+      }
+      this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+      this._timeouts = timeouts;
+      this._options = options || {};
+      this._maxRetryTime = options && options.maxRetryTime || Infinity;
+      this._fn = null;
+      this._errors = [];
+      this._attempts = 1;
+      this._operationTimeout = null;
+      this._operationTimeoutCb = null;
+      this._timeout = null;
+      this._operationStart = null;
+      this._timer = null;
+      if (this._options.forever) {
+        this._cachedTimeouts = this._timeouts.slice(0);
+      }
+    }
+    module2.exports = RetryOperation;
+    RetryOperation.prototype.reset = function() {
+      this._attempts = 1;
+      this._timeouts = this._originalTimeouts.slice(0);
+    };
+    RetryOperation.prototype.stop = function() {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (this._timer) {
+        clearTimeout(this._timer);
+      }
+      this._timeouts = [];
+      this._cachedTimeouts = null;
+    };
+    RetryOperation.prototype.retry = function(err) {
+      if (this._timeout) {
+        clearTimeout(this._timeout);
+      }
+      if (!err) {
+        return false;
+      }
+      var currentTime = (/* @__PURE__ */ new Date()).getTime();
+      if (err && currentTime - this._operationStart >= this._maxRetryTime) {
+        this._errors.push(err);
+        this._errors.unshift(new Error("RetryOperation timeout occurred"));
+        return false;
+      }
+      this._errors.push(err);
+      var timeout = this._timeouts.shift();
+      if (timeout === void 0) {
+        if (this._cachedTimeouts) {
+          this._errors.splice(0, this._errors.length - 1);
+          timeout = this._cachedTimeouts.slice(-1);
+        } else {
+          return false;
+        }
+      }
+      var self = this;
+      this._timer = setTimeout(function() {
+        self._attempts++;
+        if (self._operationTimeoutCb) {
+          self._timeout = setTimeout(function() {
+            self._operationTimeoutCb(self._attempts);
+          }, self._operationTimeout);
+          if (self._options.unref) {
+            self._timeout.unref();
+          }
+        }
+        self._fn(self._attempts);
+      }, timeout);
+      if (this._options.unref) {
+        this._timer.unref();
+      }
+      return true;
+    };
+    RetryOperation.prototype.attempt = function(fn, timeoutOps) {
+      this._fn = fn;
+      if (timeoutOps) {
+        if (timeoutOps.timeout) {
+          this._operationTimeout = timeoutOps.timeout;
+        }
+        if (timeoutOps.cb) {
+          this._operationTimeoutCb = timeoutOps.cb;
+        }
+      }
+      var self = this;
+      if (this._operationTimeoutCb) {
+        this._timeout = setTimeout(function() {
+          self._operationTimeoutCb();
+        }, self._operationTimeout);
+      }
+      this._operationStart = (/* @__PURE__ */ new Date()).getTime();
+      this._fn(this._attempts);
+    };
+    RetryOperation.prototype.try = function(fn) {
+      console.log("Using RetryOperation.try() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = function(fn) {
+      console.log("Using RetryOperation.start() is deprecated");
+      this.attempt(fn);
+    };
+    RetryOperation.prototype.start = RetryOperation.prototype.try;
+    RetryOperation.prototype.errors = function() {
+      return this._errors;
+    };
+    RetryOperation.prototype.attempts = function() {
+      return this._attempts;
+    };
+    RetryOperation.prototype.mainError = function() {
+      if (this._errors.length === 0) {
+        return null;
+      }
+      var counts = {};
+      var mainError = null;
+      var mainErrorCount = 0;
+      for (var i = 0; i < this._errors.length; i++) {
+        var error = this._errors[i];
+        var message = error.message;
+        var count = (counts[message] || 0) + 1;
+        counts[message] = count;
+        if (count >= mainErrorCount) {
+          mainError = error;
+          mainErrorCount = count;
+        }
+      }
+      return mainError;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js
+var require_retry = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js"(exports) {
+    "use strict";
+    var RetryOperation = require_retry_operation();
+    exports.operation = function(options) {
+      var timeouts = exports.timeouts(options);
+      return new RetryOperation(timeouts, {
+        forever: options && (options.forever || options.retries === Infinity),
+        unref: options && options.unref,
+        maxRetryTime: options && options.maxRetryTime
+      });
+    };
+    exports.timeouts = function(options) {
+      if (options instanceof Array) {
+        return [].concat(options);
+      }
+      var opts = {
+        retries: 10,
+        factor: 2,
+        minTimeout: 1 * 1e3,
+        maxTimeout: Infinity,
+        randomize: false
+      };
+      for (var key in options) {
+        opts[key] = options[key];
+      }
+      if (opts.minTimeout > opts.maxTimeout) {
+        throw new Error("minTimeout is greater than maxTimeout");
+      }
+      var timeouts = [];
+      for (var i = 0; i < opts.retries; i++) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      if (options && options.forever && !timeouts.length) {
+        timeouts.push(this.createTimeout(i, opts));
+      }
+      timeouts.sort(function(a, b) {
+        return a - b;
+      });
+      return timeouts;
+    };
+    exports.createTimeout = function(attempt, opts) {
+      var random = opts.randomize ? Math.random() + 1 : 1;
+      var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt));
+      timeout = Math.min(timeout, opts.maxTimeout);
+      return timeout;
+    };
+    exports.wrap = function(obj, options, methods) {
+      if (options instanceof Array) {
+        methods = options;
+        options = null;
+      }
+      if (!methods) {
+        methods = [];
+        for (var key in obj) {
+          if (typeof obj[key] === "function") {
+            methods.push(key);
+          }
+        }
+      }
+      for (var i = 0; i < methods.length; i++) {
+        var method = methods[i];
+        var original = obj[method];
+        obj[method] = function retryWrapper(original2) {
+          var op = exports.operation(options);
+          var args = Array.prototype.slice.call(arguments, 1);
+          var callback = args.pop();
+          args.push(function(err) {
+            if (op.retry(err)) {
+              return;
+            }
+            if (err) {
+              arguments[0] = op.mainError();
+            }
+            callback.apply(this, arguments);
+          });
+          op.attempt(function() {
+            original2.apply(obj, args);
+          });
+        }.bind(obj, original);
+        obj[method].options = options;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js
+var require_retry2 = __commonJS({
+  "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = require_retry();
+  }
+});
+
+// ../../node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js
+var require_p_retry = __commonJS({
+  "../../node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js"(exports, module2) {
+    "use strict";
+    var retry = require_retry2();
+    var networkErrorMsgs = [
+      "Failed to fetch",
+      // Chrome
+      "NetworkError when attempting to fetch resource.",
+      // Firefox
+      "The Internet connection appears to be offline.",
+      // Safari
+      "Network request failed"
+      // `cross-fetch`
+    ];
+    var AbortError = class extends Error {
+      constructor(message) {
+        super();
+        if (message instanceof Error) {
+          this.originalError = message;
+          ({ message } = message);
+        } else {
+          this.originalError = new Error(message);
+          this.originalError.stack = this.stack;
+        }
+        this.name = "AbortError";
+        this.message = message;
+      }
+    };
+    var decorateErrorWithCounts = (error, attemptNumber, options) => {
+      const retriesLeft = options.retries - (attemptNumber - 1);
+      error.attemptNumber = attemptNumber;
+      error.retriesLeft = retriesLeft;
+      return error;
+    };
+    var isNetworkError = (errorMessage) => networkErrorMsgs.includes(errorMessage);
+    var pRetry2 = (input, options) => new Promise((resolve, reject) => {
+      options = __spreadValues({
+        onFailedAttempt: () => {
+        },
+        retries: 10
+      }, options);
+      const operation = retry.operation(options);
+      operation.attempt(async (attemptNumber) => {
+        try {
+          resolve(await input(attemptNumber));
+        } catch (error) {
+          if (!(error instanceof Error)) {
+            reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+            return;
+          }
+          if (error instanceof AbortError) {
+            operation.stop();
+            reject(error.originalError);
+          } else if (error instanceof TypeError && !isNetworkError(error.message)) {
+            operation.stop();
+            reject(error);
+          } else {
+            decorateErrorWithCounts(error, attemptNumber, options);
+            try {
+              await options.onFailedAttempt(error);
+            } catch (error2) {
+              reject(error2);
+              return;
+            }
+            if (!operation.retry(error)) {
+              reject(operation.mainError());
+            }
+          }
+        }
+      });
+    });
+    module2.exports = pRetry2;
+    module2.exports.default = pRetry2;
+    module2.exports.AbortError = AbortError;
+  }
+});
+
+// ../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js"(exports, module2) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events();
+      else
+        delete emitter._events[evt];
+    }
+    function EventEmitter() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1); j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+    EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+    EventEmitter.prefixed = prefix;
+    EventEmitter.EventEmitter = EventEmitter;
+    if ("undefined" !== typeof module2) {
+      module2.exports = EventEmitter;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js
+var require_p_finally = __commonJS({
+  "../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = (promise, onFinally) => {
+      onFinally = onFinally || (() => {
+      });
+      return promise.then(
+        (val) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => val),
+        (err) => new Promise((resolve) => {
+          resolve(onFinally());
+        }).then(() => {
+          throw err;
+        })
+      );
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js
+var require_p_timeout = __commonJS({
+  "../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js"(exports, module2) {
+    "use strict";
+    var pFinally = require_p_finally();
+    var TimeoutError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "TimeoutError";
+      }
+    };
+    var pTimeout = (promise, milliseconds, fallback) => new Promise((resolve, reject) => {
+      if (typeof milliseconds !== "number" || milliseconds < 0) {
+        throw new TypeError("Expected `milliseconds` to be a positive number");
+      }
+      if (milliseconds === Infinity) {
+        resolve(promise);
+        return;
+      }
+      const timer = setTimeout(() => {
+        if (typeof fallback === "function") {
+          try {
+            resolve(fallback());
+          } catch (error) {
+            reject(error);
+          }
+          return;
+        }
+        const message = typeof fallback === "string" ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+        const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
+        if (typeof promise.cancel === "function") {
+          promise.cancel();
+        }
+        reject(timeoutError);
+      }, milliseconds);
+      pFinally(
+        // eslint-disable-next-line promise/prefer-await-to-then
+        promise.then(resolve, reject),
+        () => {
+          clearTimeout(timer);
+        }
+      );
+    });
+    module2.exports = pTimeout;
+    module2.exports.default = pTimeout;
+    module2.exports.TimeoutError = TimeoutError;
+  }
+});
+
+// ../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js
+var require_lower_bound = __commonJS({
+  "../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function lowerBound(array, value, comparator) {
+      let first = 0;
+      let count = array.length;
+      while (count > 0) {
+        const step = count / 2 | 0;
+        let it = first + step;
+        if (comparator(array[it], value) <= 0) {
+          first = ++it;
+          count -= step + 1;
+        } else {
+          count = step;
+        }
+      }
+      return first;
+    }
+    exports.default = lowerBound;
+  }
+});
+
+// ../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js
+var require_priority_queue = __commonJS({
+  "../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var lower_bound_1 = require_lower_bound();
+    var PriorityQueue = class {
+      constructor() {
+        this._queue = [];
+      }
+      enqueue(run, options) {
+        options = Object.assign({ priority: 0 }, options);
+        const element = {
+          priority: options.priority,
+          run
+        };
+        if (this.size && this._queue[this.size - 1].priority >= options.priority) {
+          this._queue.push(element);
+          return;
+        }
+        const index = lower_bound_1.default(this._queue, element, (a, b) => b.priority - a.priority);
+        this._queue.splice(index, 0, element);
+      }
+      dequeue() {
+        const item = this._queue.shift();
+        return item === null || item === void 0 ? void 0 : item.run;
+      }
+      filter(options) {
+        return this._queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+      }
+      get size() {
+        return this._queue.length;
+      }
+    };
+    exports.default = PriorityQueue;
+  }
+});
+
+// ../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js
+var require_dist = __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 });
+    var EventEmitter = require_eventemitter3();
+    var p_timeout_1 = require_p_timeout();
+    var priority_queue_1 = require_priority_queue();
+    var empty = () => {
+    };
+    var timeoutError = new p_timeout_1.TimeoutError();
+    var PQueue = class extends EventEmitter {
+      constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        this._intervalCount = 0;
+        this._intervalEnd = 0;
+        this._pendingCount = 0;
+        this._resolveEmpty = empty;
+        this._resolveIdle = empty;
+        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
+        if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+          throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""}\` (${typeof options.intervalCap})`);
+        }
+        if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+          throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ""}\` (${typeof options.interval})`);
+        }
+        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
+        this._intervalCap = options.intervalCap;
+        this._interval = options.interval;
+        this._queue = new options.queueClass();
+        this._queueClass = options.queueClass;
+        this.concurrency = options.concurrency;
+        this._timeout = options.timeout;
+        this._throwOnTimeout = options.throwOnTimeout === true;
+        this._isPaused = options.autoStart === false;
+      }
+      get _doesIntervalAllowAnother() {
+        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
+      }
+      get _doesConcurrentAllowAnother() {
+        return this._pendingCount < this._concurrency;
+      }
+      _next() {
+        this._pendingCount--;
+        this._tryToStartAnother();
+        this.emit("next");
+      }
+      _resolvePromises() {
+        this._resolveEmpty();
+        this._resolveEmpty = empty;
+        if (this._pendingCount === 0) {
+          this._resolveIdle();
+          this._resolveIdle = empty;
+          this.emit("idle");
+        }
+      }
+      _onResumeInterval() {
+        this._onInterval();
+        this._initializeIntervalIfNeeded();
+        this._timeoutId = void 0;
+      }
+      _isIntervalPaused() {
+        const now = Date.now();
+        if (this._intervalId === void 0) {
+          const delay = this._intervalEnd - now;
+          if (delay < 0) {
+            this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+          } else {
+            if (this._timeoutId === void 0) {
+              this._timeoutId = setTimeout(() => {
+                this._onResumeInterval();
+              }, delay);
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _tryToStartAnother() {
+        if (this._queue.size === 0) {
+          if (this._intervalId) {
+            clearInterval(this._intervalId);
+          }
+          this._intervalId = void 0;
+          this._resolvePromises();
+          return false;
+        }
+        if (!this._isPaused) {
+          const canInitializeInterval = !this._isIntervalPaused();
+          if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
+            const job = this._queue.dequeue();
+            if (!job) {
+              return false;
+            }
+            this.emit("active");
+            job();
+            if (canInitializeInterval) {
+              this._initializeIntervalIfNeeded();
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+      _initializeIntervalIfNeeded() {
+        if (this._isIntervalIgnored || this._intervalId !== void 0) {
+          return;
+        }
+        this._intervalId = setInterval(() => {
+          this._onInterval();
+        }, this._interval);
+        this._intervalEnd = Date.now() + this._interval;
+      }
+      _onInterval() {
+        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
+          clearInterval(this._intervalId);
+          this._intervalId = void 0;
+        }
+        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+        this._processQueue();
+      }
+      /**
+      Executes all queued functions until it reaches the limit.
+      */
+      _processQueue() {
+        while (this._tryToStartAnother()) {
+        }
+      }
+      get concurrency() {
+        return this._concurrency;
+      }
+      set concurrency(newConcurrency) {
+        if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+          throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+        }
+        this._concurrency = newConcurrency;
+        this._processQueue();
+      }
+      /**
+      Adds a sync or async task to the queue. Always returns a promise.
+      */
+      async add(fn, options = {}) {
+        return new Promise((resolve, reject) => {
+          const run = async () => {
+            this._pendingCount++;
+            this._intervalCount++;
+            try {
+              const operation = this._timeout === void 0 && options.timeout === void 0 ? fn() : p_timeout_1.default(Promise.resolve(fn()), options.timeout === void 0 ? this._timeout : options.timeout, () => {
+                if (options.throwOnTimeout === void 0 ? this._throwOnTimeout : options.throwOnTimeout) {
+                  reject(timeoutError);
+                }
+                return void 0;
+              });
+              resolve(await operation);
+            } catch (error) {
+              reject(error);
+            }
+            this._next();
+          };
+          this._queue.enqueue(run, options);
+          this._tryToStartAnother();
+          this.emit("add");
+        });
+      }
+      /**
+          Same as `.add()`, but accepts an array of sync or async functions.
+      
+          @returns A promise that resolves when all functions are resolved.
+          */
+      async addAll(functions, options) {
+        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+      }
+      /**
+      Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+      */
+      start() {
+        if (!this._isPaused) {
+          return this;
+        }
+        this._isPaused = false;
+        this._processQueue();
+        return this;
+      }
+      /**
+      Put queue execution on hold.
+      */
+      pause() {
+        this._isPaused = true;
+      }
+      /**
+      Clear the queue.
+      */
+      clear() {
+        this._queue = new this._queueClass();
+      }
+      /**
+          Can be called multiple times. Useful if you for example add additional items at a later time.
+      
+          @returns A promise that settles when the queue becomes empty.
+          */
+      async onEmpty() {
+        if (this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve) => {
+          const existingResolve = this._resolveEmpty;
+          this._resolveEmpty = () => {
+            existingResolve();
+            resolve();
+          };
+        });
+      }
+      /**
+          The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+      
+          @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+          */
+      async onIdle() {
+        if (this._pendingCount === 0 && this._queue.size === 0) {
+          return;
+        }
+        return new Promise((resolve) => {
+          const existingResolve = this._resolveIdle;
+          this._resolveIdle = () => {
+            existingResolve();
+            resolve();
+          };
+        });
+      }
+      /**
+      Size of the queue.
+      */
+      get size() {
+        return this._queue.size;
+      }
+      /**
+          Size of the queue, filtered by the given options.
+      
+          For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+          */
+      sizeBy(options) {
+        return this._queue.filter(options).length;
+      }
+      /**
+      Number of pending promises.
+      */
+      get pending() {
+        return this._pendingCount;
+      }
+      /**
+      Whether the queue is currently paused.
+      */
+      get isPaused() {
+        return this._isPaused;
+      }
+      get timeout() {
+        return this._timeout;
+      }
+      /**
+      Set the timeout for future operations.
+      */
+      set timeout(milliseconds) {
+        this._timeout = milliseconds;
+      }
+    };
+    exports.default = PQueue;
+  }
+});
+
+// src/ai-model/index.ts
+var ai_model_exports = {};
+__export(ai_model_exports, {
+  AiExtractElementInfo: () => AiExtractElementInfo,
+  AiInspectElement: () => AiInspectElement,
+  callToGetJSONObject: () => callToGetJSONObject,
+  describeUserPage: () => describeUserPage,
+  systemPromptToFindElement: () => systemPromptToFindElement
+});
+module.exports = __toCommonJS(ai_model_exports);
+
+// src/ai-model/openai.ts
+var import_assert = __toESM(require("assert"));
+var import_openai = __toESM(require("openai"));
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/traceable.js
+var import_node_async_hooks = require("async_hooks");
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js
+var import_crypto = __toESM(require("crypto"));
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/regex.js
+var regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default = validate;
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/native.js
+var import_crypto2 = __toESM(require("crypto"));
+var native_default = {
+  randomUUID: import_crypto2.default.randomUUID
+};
+
+// ../../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/async_caller.js
+var import_p_retry = __toESM(require_p_retry());
+var import_p_queue = __toESM(require_dist());
+var STATUS_NO_RETRY = [
+  400,
+  // Bad Request
+  401,
+  // Unauthorized
+  403,
+  // Forbidden
+  404,
+  // Not Found
+  405,
+  // Method Not Allowed
+  406,
+  // Not Acceptable
+  407,
+  // Proxy Authentication Required
+  408
+  // Request Timeout
+];
+var STATUS_IGNORE = [
+  409
+  // Conflict
+];
+var AsyncCaller = class {
+  constructor(params) {
+    var _a, _b;
+    Object.defineProperty(this, "maxConcurrency", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "maxRetries", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "queue", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "onFailedResponseHook", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.maxConcurrency = (_a = params.maxConcurrency) != null ? _a : Infinity;
+    this.maxRetries = (_b = params.maxRetries) != null ? _b : 6;
+    if ("default" in import_p_queue.default) {
+      this.queue = new import_p_queue.default.default({
+        concurrency: this.maxConcurrency
+      });
+    } else {
+      this.queue = new import_p_queue.default({ concurrency: this.maxConcurrency });
+    }
+    this.onFailedResponseHook = params == null ? void 0 : params.onFailedResponseHook;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  call(callable, ...args) {
+    const onFailedResponseHook = this.onFailedResponseHook;
+    return this.queue.add(() => (0, import_p_retry.default)(() => callable(...args).catch((error) => {
+      if (error instanceof Error) {
+        throw error;
+      } else {
+        throw new Error(error);
+      }
+    }), {
+      async onFailedAttempt(error) {
+        if (error.message.startsWith("Cancel") || error.message.startsWith("TimeoutError") || error.message.startsWith("AbortError")) {
+          throw error;
+        }
+        if ((error == null ? void 0 : error.code) === "ECONNABORTED") {
+          throw error;
+        }
+        const response = error == null ? void 0 : error.response;
+        const status = response == null ? void 0 : response.status;
+        if (status) {
+          if (STATUS_NO_RETRY.includes(+status)) {
+            throw error;
+          } else if (STATUS_IGNORE.includes(+status)) {
+            return;
+          }
+          if (onFailedResponseHook) {
+            await onFailedResponseHook(response);
+          }
+        }
+      },
+      // If needed we can change some of the defaults here,
+      // but they're quite sensible.
+      retries: this.maxRetries,
+      randomize: true
+    }), { throwOnTimeout: true });
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callWithOptions(options, callable, ...args) {
+    if (options.signal) {
+      return Promise.race([
+        this.call(callable, ...args),
+        new Promise((_, reject) => {
+          var _a;
+          (_a = options.signal) == null ? void 0 : _a.addEventListener("abort", () => {
+            reject(new Error("AbortError"));
+          });
+        })
+      ]);
+    }
+    return this.call(callable, ...args);
+  }
+  fetch(...args) {
+    return this.call(() => fetch(...args).then((res) => res.ok ? res : Promise.reject(res)));
+  }
+};
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/messages.js
+function isLangChainMessage(message) {
+  return typeof (message == null ? void 0 : message._getType) === "function";
+}
+function convertLangChainMessageToExample(message) {
+  const converted = {
+    type: message._getType(),
+    data: { content: message.content }
+  };
+  if ((message == null ? void 0 : message.additional_kwargs) && Object.keys(message.additional_kwargs).length > 0) {
+    converted.data.additional_kwargs = __spreadValues({}, message.additional_kwargs);
+  }
+  return converted;
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/_uuid.js
+function assertUuid(str) {
+  if (!validate_default(str)) {
+    throw new Error(`Invalid UUID: ${str}`);
+  }
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/warn.js
+var warnedMessages = {};
+function warnOnce(message) {
+  if (!warnedMessages[message]) {
+    console.warn(message);
+    warnedMessages[message] = true;
+  }
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/client.js
+async function mergeRuntimeEnvIntoRunCreates(runs) {
+  const runtimeEnv = await getRuntimeEnvironment();
+  const envVars = getLangChainEnvVarsMetadata();
+  return runs.map((run) => {
+    var _a, _b;
+    const extra = (_a = run.extra) != null ? _a : {};
+    const metadata = extra.metadata;
+    run.extra = __spreadProps(__spreadValues({}, extra), {
+      runtime: __spreadValues(__spreadValues({}, runtimeEnv), extra == null ? void 0 : extra.runtime),
+      metadata: __spreadValues(__spreadValues(__spreadValues({}, envVars), envVars.revision_id || run.revision_id ? { revision_id: (_b = run.revision_id) != null ? _b : envVars.revision_id } : {}), metadata)
+    });
+    return run;
+  });
+}
+var getTracingSamplingRate = () => {
+  const samplingRateStr = getEnvironmentVariable("LANGCHAIN_TRACING_SAMPLING_RATE");
+  if (samplingRateStr === void 0) {
+    return void 0;
+  }
+  const samplingRate = parseFloat(samplingRateStr);
+  if (samplingRate < 0 || samplingRate > 1) {
+    throw new Error(`LANGCHAIN_TRACING_SAMPLING_RATE must be between 0 and 1 if set. Got: ${samplingRate}`);
+  }
+  return samplingRate;
+};
+var isLocalhost = (url) => {
+  const strippedUrl = url.replace("http://", "").replace("https://", "");
+  const hostname = strippedUrl.split("/")[0].split(":")[0];
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+};
+var raiseForStatus = async (response, operation) => {
+  const body = await response.text();
+  if (!response.ok) {
+    throw new Error(`Failed to ${operation}: ${response.status} ${response.statusText} ${body}`);
+  }
+};
+async function toArray(iterable) {
+  const result = [];
+  try {
+    for (var iter = __forAwait(iterable), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+      const item = temp.value;
+      result.push(item);
+    }
+  } catch (temp) {
+    error = [temp];
+  } finally {
+    try {
+      more && (temp = iter.return) && await temp.call(iter);
+    } finally {
+      if (error)
+        throw error[0];
+    }
+  }
+  return result;
+}
+function trimQuotes(str) {
+  if (str === void 0) {
+    return void 0;
+  }
+  return str.trim().replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+}
+var handle429 = async (response) => {
+  var _a;
+  if ((response == null ? void 0 : response.status) === 429) {
+    const retryAfter = parseInt((_a = response.headers.get("retry-after")) != null ? _a : "30", 10) * 1e3;
+    if (retryAfter > 0) {
+      await new Promise((resolve) => setTimeout(resolve, retryAfter));
+      return true;
+    }
+  }
+  return false;
+};
+var Queue = class {
+  constructor() {
+    Object.defineProperty(this, "items", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: []
+    });
+  }
+  get size() {
+    return this.items.length;
+  }
+  push(item) {
+    return new Promise((resolve) => {
+      this.items.push([item, resolve]);
+    });
+  }
+  pop(upToN) {
+    if (upToN < 1) {
+      throw new Error("Number of items to pop off may not be less than 1.");
+    }
+    const popped = [];
+    while (popped.length < upToN && this.items.length) {
+      const item = this.items.shift();
+      if (item) {
+        popped.push(item);
+      } else {
+        break;
+      }
+    }
+    return [popped.map((it) => it[0]), () => popped.forEach((it) => it[1]())];
+  }
+};
+var DEFAULT_BATCH_SIZE_LIMIT_BYTES = 20971520;
+var Client = class _Client {
+  constructor(config = {}) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+    Object.defineProperty(this, "apiKey", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "apiUrl", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "webUrl", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "caller", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "batchIngestCaller", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "timeout_ms", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_tenantId", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: null
+    });
+    Object.defineProperty(this, "hideInputs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "hideOutputs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "tracingSampleRate", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "sampledPostUuids", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: /* @__PURE__ */ new Set()
+    });
+    Object.defineProperty(this, "autoBatchTracing", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: true
+    });
+    Object.defineProperty(this, "batchEndpointSupported", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "autoBatchQueue", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new Queue()
+    });
+    Object.defineProperty(this, "pendingAutoBatchedRunLimit", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 100
+    });
+    Object.defineProperty(this, "autoBatchTimeout", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "autoBatchInitialDelayMs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 250
+    });
+    Object.defineProperty(this, "autoBatchAggregationDelayMs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 50
+    });
+    Object.defineProperty(this, "serverInfo", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "fetchOptions", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    const defaultConfig = _Client.getDefaultClientConfig();
+    this.tracingSampleRate = getTracingSamplingRate();
+    this.apiUrl = (_b = trimQuotes((_a = config.apiUrl) != null ? _a : defaultConfig.apiUrl)) != null ? _b : "";
+    this.apiKey = trimQuotes((_c = config.apiKey) != null ? _c : defaultConfig.apiKey);
+    this.webUrl = trimQuotes((_d = config.webUrl) != null ? _d : defaultConfig.webUrl);
+    this.timeout_ms = (_e = config.timeout_ms) != null ? _e : 12e3;
+    this.caller = new AsyncCaller((_f = config.callerOptions) != null ? _f : {});
+    this.batchIngestCaller = new AsyncCaller(__spreadProps(__spreadValues({}, (_g = config.callerOptions) != null ? _g : {}), {
+      onFailedResponseHook: handle429
+    }));
+    this.hideInputs = (_i = (_h = config.hideInputs) != null ? _h : config.anonymizer) != null ? _i : defaultConfig.hideInputs;
+    this.hideOutputs = (_k = (_j = config.hideOutputs) != null ? _j : config.anonymizer) != null ? _k : defaultConfig.hideOutputs;
+    this.autoBatchTracing = (_l = config.autoBatchTracing) != null ? _l : this.autoBatchTracing;
+    this.pendingAutoBatchedRunLimit = (_m = config.pendingAutoBatchedRunLimit) != null ? _m : this.pendingAutoBatchedRunLimit;
+    this.fetchOptions = config.fetchOptions || {};
+  }
+  static getDefaultClientConfig() {
+    var _a;
+    const apiKey = getEnvironmentVariable("LANGCHAIN_API_KEY");
+    const apiUrl = (_a = getEnvironmentVariable("LANGCHAIN_ENDPOINT")) != null ? _a : "https://api.smith.langchain.com";
+    const hideInputs = getEnvironmentVariable("LANGCHAIN_HIDE_INPUTS") === "true";
+    const hideOutputs = getEnvironmentVariable("LANGCHAIN_HIDE_OUTPUTS") === "true";
+    return {
+      apiUrl,
+      apiKey,
+      webUrl: void 0,
+      hideInputs,
+      hideOutputs
+    };
+  }
+  getHostUrl() {
+    if (this.webUrl) {
+      return this.webUrl;
+    } else if (isLocalhost(this.apiUrl)) {
+      this.webUrl = "http://localhost:3000";
+      return this.webUrl;
+    } else if (this.apiUrl.includes("/api") && !this.apiUrl.split(".", 1)[0].endsWith("api")) {
+      this.webUrl = this.apiUrl.replace("/api", "");
+      return this.webUrl;
+    } else if (this.apiUrl.split(".", 1)[0].includes("dev")) {
+      this.webUrl = "https://dev.smith.langchain.com";
+      return this.webUrl;
+    } else {
+      this.webUrl = "https://smith.langchain.com";
+      return this.webUrl;
+    }
+  }
+  get headers() {
+    const headers = {
+      "User-Agent": `langsmith-js/${__version__}`
+    };
+    if (this.apiKey) {
+      headers["x-api-key"] = `${this.apiKey}`;
+    }
+    return headers;
+  }
+  processInputs(inputs) {
+    if (this.hideInputs === false) {
+      return inputs;
+    }
+    if (this.hideInputs === true) {
+      return {};
+    }
+    if (typeof this.hideInputs === "function") {
+      return this.hideInputs(inputs);
+    }
+    return inputs;
+  }
+  processOutputs(outputs) {
+    if (this.hideOutputs === false) {
+      return outputs;
+    }
+    if (this.hideOutputs === true) {
+      return {};
+    }
+    if (typeof this.hideOutputs === "function") {
+      return this.hideOutputs(outputs);
+    }
+    return outputs;
+  }
+  prepareRunCreateOrUpdateInputs(run) {
+    const runParams = __spreadValues({}, run);
+    if (runParams.inputs !== void 0) {
+      runParams.inputs = this.processInputs(runParams.inputs);
+    }
+    if (runParams.outputs !== void 0) {
+      runParams.outputs = this.processOutputs(runParams.outputs);
+    }
+    return runParams;
+  }
+  async _getResponse(path, queryParams) {
+    var _a;
+    const paramsString = (_a = queryParams == null ? void 0 : queryParams.toString()) != null ? _a : "";
+    const url = `${this.apiUrl}${path}?${paramsString}`;
+    const response = await this.caller.call(fetch, url, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+    }
+    return response;
+  }
+  async _get(path, queryParams) {
+    const response = await this._getResponse(path, queryParams);
+    return response.json();
+  }
+  _getPaginated(_0) {
+    return __asyncGenerator(this, arguments, function* (path, queryParams = new URLSearchParams()) {
+      let offset = Number(queryParams.get("offset")) || 0;
+      const limit = Number(queryParams.get("limit")) || 100;
+      while (true) {
+        queryParams.set("offset", String(offset));
+        queryParams.set("limit", String(limit));
+        const url = `${this.apiUrl}${path}?${queryParams}`;
+        const response = yield new __await(this.caller.call(fetch, url, __spreadValues({
+          method: "GET",
+          headers: this.headers,
+          signal: AbortSignal.timeout(this.timeout_ms)
+        }, this.fetchOptions)));
+        if (!response.ok) {
+          throw new Error(`Failed to fetch ${path}: ${response.status} ${response.statusText}`);
+        }
+        const items = yield new __await(response.json());
+        if (items.length === 0) {
+          break;
+        }
+        yield items;
+        if (items.length < limit) {
+          break;
+        }
+        offset += items.length;
+      }
+    });
+  }
+  _getCursorPaginatedList(path, body = null, requestMethod = "POST", dataKey = "runs") {
+    return __asyncGenerator(this, null, function* () {
+      const bodyParams = body ? __spreadValues({}, body) : {};
+      while (true) {
+        const response = yield new __await(this.caller.call(fetch, `${this.apiUrl}${path}`, __spreadProps(__spreadValues({
+          method: requestMethod,
+          headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+          signal: AbortSignal.timeout(this.timeout_ms)
+        }, this.fetchOptions), {
+          body: JSON.stringify(bodyParams)
+        })));
+        const responseBody = yield new __await(response.json());
+        if (!responseBody) {
+          break;
+        }
+        if (!responseBody[dataKey]) {
+          break;
+        }
+        yield responseBody[dataKey];
+        const cursors = responseBody.cursors;
+        if (!cursors) {
+          break;
+        }
+        if (!cursors.next) {
+          break;
+        }
+        bodyParams.cursor = cursors.next;
+      }
+    });
+  }
+  _filterForSampling(runs, patch = false) {
+    if (this.tracingSampleRate === void 0) {
+      return runs;
+    }
+    if (patch) {
+      const sampled = [];
+      for (const run of runs) {
+        if (this.sampledPostUuids.has(run.id)) {
+          sampled.push(run);
+          this.sampledPostUuids.delete(run.id);
+        }
+      }
+      return sampled;
+    } else {
+      const sampled = [];
+      for (const run of runs) {
+        if (Math.random() < this.tracingSampleRate) {
+          sampled.push(run);
+          this.sampledPostUuids.add(run.id);
+        }
+      }
+      return sampled;
+    }
+  }
+  async drainAutoBatchQueue() {
+    while (this.autoBatchQueue.size >= 0) {
+      const [batch, done] = this.autoBatchQueue.pop(this.pendingAutoBatchedRunLimit);
+      if (!batch.length) {
+        done();
+        return;
+      }
+      try {
+        await this.batchIngestRuns({
+          runCreates: batch.filter((item) => item.action === "create").map((item) => item.item),
+          runUpdates: batch.filter((item) => item.action === "update").map((item) => item.item)
+        });
+      } finally {
+        done();
+      }
+    }
+  }
+  async processRunOperation(item, immediatelyTriggerBatch) {
+    const oldTimeout = this.autoBatchTimeout;
+    clearTimeout(this.autoBatchTimeout);
+    this.autoBatchTimeout = void 0;
+    const itemPromise = this.autoBatchQueue.push(item);
+    if (immediatelyTriggerBatch || this.autoBatchQueue.size > this.pendingAutoBatchedRunLimit) {
+      await this.drainAutoBatchQueue();
+    }
+    if (this.autoBatchQueue.size > 0) {
+      this.autoBatchTimeout = setTimeout(() => {
+        this.autoBatchTimeout = void 0;
+        void this.drainAutoBatchQueue().catch(console.error);
+      }, oldTimeout ? this.autoBatchAggregationDelayMs : this.autoBatchInitialDelayMs);
+    }
+    return itemPromise;
+  }
+  async _getServerInfo() {
+    const response = await fetch(`${this.apiUrl}/info`, __spreadValues({
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      await response.text();
+      throw new Error("Failed to retrieve server info.");
+    }
+    return response.json();
+  }
+  async batchEndpointIsSupported() {
+    try {
+      this.serverInfo = await this._getServerInfo();
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+  async createRun(run) {
+    var _a;
+    if (!this._filterForSampling([run]).length) {
+      return;
+    }
+    const headers = __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" });
+    const session_name = run.project_name;
+    delete run.project_name;
+    const runCreate = this.prepareRunCreateOrUpdateInputs(__spreadProps(__spreadValues({
+      session_name
+    }, run), {
+      start_time: (_a = run.start_time) != null ? _a : Date.now()
+    }));
+    if (this.autoBatchTracing && runCreate.trace_id !== void 0 && runCreate.dotted_order !== void 0) {
+      void this.processRunOperation({
+        action: "create",
+        item: runCreate
+      }).catch(console.error);
+      return;
+    }
+    const mergedRunCreateParams = await mergeRuntimeEnvIntoRunCreates([
+      runCreate
+    ]);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/runs`, __spreadValues({
+      method: "POST",
+      headers,
+      body: JSON.stringify(mergedRunCreateParams[0]),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "create run");
+  }
+  /**
+   * Batch ingest/upsert multiple runs in the Langsmith system.
+   * @param runs
+   */
+  async batchIngestRuns({ runCreates, runUpdates }) {
+    var _a, _b, _c, _d, _e;
+    if (runCreates === void 0 && runUpdates === void 0) {
+      return;
+    }
+    let preparedCreateParams = (_a = runCreates == null ? void 0 : runCreates.map((create) => this.prepareRunCreateOrUpdateInputs(create))) != null ? _a : [];
+    let preparedUpdateParams = (_b = runUpdates == null ? void 0 : runUpdates.map((update) => this.prepareRunCreateOrUpdateInputs(update))) != null ? _b : [];
+    if (preparedCreateParams.length > 0 && preparedUpdateParams.length > 0) {
+      const createById = preparedCreateParams.reduce((params, run) => {
+        if (!run.id) {
+          return params;
+        }
+        params[run.id] = run;
+        return params;
+      }, {});
+      const standaloneUpdates = [];
+      for (const updateParam of preparedUpdateParams) {
+        if (updateParam.id !== void 0 && createById[updateParam.id]) {
+          createById[updateParam.id] = __spreadValues(__spreadValues({}, createById[updateParam.id]), updateParam);
+        } else {
+          standaloneUpdates.push(updateParam);
+        }
+      }
+      preparedCreateParams = Object.values(createById);
+      preparedUpdateParams = standaloneUpdates;
+    }
+    const rawBatch = {
+      post: this._filterForSampling(preparedCreateParams),
+      patch: this._filterForSampling(preparedUpdateParams, true)
+    };
+    if (!rawBatch.post.length && !rawBatch.patch.length) {
+      return;
+    }
+    preparedCreateParams = await mergeRuntimeEnvIntoRunCreates(preparedCreateParams);
+    if (this.batchEndpointSupported === void 0) {
+      this.batchEndpointSupported = await this.batchEndpointIsSupported();
+    }
+    if (!this.batchEndpointSupported) {
+      this.autoBatchTracing = false;
+      for (const preparedCreateParam of rawBatch.post) {
+        await this.createRun(preparedCreateParam);
+      }
+      for (const preparedUpdateParam of rawBatch.patch) {
+        if (preparedUpdateParam.id !== void 0) {
+          await this.updateRun(preparedUpdateParam.id, preparedUpdateParam);
+        }
+      }
+      return;
+    }
+    const sizeLimitBytes = (_e = (_d = (_c = this.serverInfo) == null ? void 0 : _c.batch_ingest_config) == null ? void 0 : _d.size_limit_bytes) != null ? _e : DEFAULT_BATCH_SIZE_LIMIT_BYTES;
+    const batchChunks = {
+      post: [],
+      patch: []
+    };
+    let currentBatchSizeBytes = 0;
+    for (const k of ["post", "patch"]) {
+      const key = k;
+      const batchItems = rawBatch[key].reverse();
+      let batchItem = batchItems.pop();
+      while (batchItem !== void 0) {
+        const stringifiedBatchItem = JSON.stringify(batchItem);
+        if (currentBatchSizeBytes > 0 && currentBatchSizeBytes + stringifiedBatchItem.length > sizeLimitBytes) {
+          await this._postBatchIngestRuns(JSON.stringify(batchChunks));
+          currentBatchSizeBytes = 0;
+          batchChunks.post = [];
+          batchChunks.patch = [];
+        }
+        currentBatchSizeBytes += stringifiedBatchItem.length;
+        batchChunks[key].push(batchItem);
+        batchItem = batchItems.pop();
+      }
+    }
+    if (batchChunks.post.length > 0 || batchChunks.patch.length > 0) {
+      await this._postBatchIngestRuns(JSON.stringify(batchChunks));
+    }
+  }
+  async _postBatchIngestRuns(body) {
+    const headers = __spreadProps(__spreadValues({}, this.headers), {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    });
+    const response = await this.batchIngestCaller.call(fetch, `${this.apiUrl}/runs/batch`, __spreadValues({
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "batch create run");
+  }
+  async updateRun(runId, run) {
+    assertUuid(runId);
+    if (run.inputs) {
+      run.inputs = this.processInputs(run.inputs);
+    }
+    if (run.outputs) {
+      run.outputs = this.processOutputs(run.outputs);
+    }
+    const data = __spreadProps(__spreadValues({}, run), { id: runId });
+    if (!this._filterForSampling([data], true).length) {
+      return;
+    }
+    if (this.autoBatchTracing && data.trace_id !== void 0 && data.dotted_order !== void 0) {
+      if (run.end_time !== void 0 && data.parent_run_id === void 0) {
+        await this.processRunOperation({ action: "update", item: data }, true);
+        return;
+      } else {
+        void this.processRunOperation({ action: "update", item: data }).catch(console.error);
+      }
+      return;
+    }
+    const headers = __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" });
+    const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}`, __spreadValues({
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(run),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "update run");
+  }
+  async readRun(runId, { loadChildRuns } = { loadChildRuns: false }) {
+    assertUuid(runId);
+    let run = await this._get(`/runs/${runId}`);
+    if (loadChildRuns && run.child_run_ids) {
+      run = await this._loadChildRuns(run);
+    }
+    return run;
+  }
+  async getRunUrl({ runId, run, projectOpts }) {
+    if (run !== void 0) {
+      let sessionId;
+      if (run.session_id) {
+        sessionId = run.session_id;
+      } else if (projectOpts == null ? void 0 : projectOpts.projectName) {
+        sessionId = (await this.readProject({ projectName: projectOpts == null ? void 0 : projectOpts.projectName })).id;
+      } else if (projectOpts == null ? void 0 : projectOpts.projectId) {
+        sessionId = projectOpts == null ? void 0 : projectOpts.projectId;
+      } else {
+        const project = await this.readProject({
+          projectName: getEnvironmentVariable("LANGCHAIN_PROJECT") || "default"
+        });
+        sessionId = project.id;
+      }
+      const tenantId = await this._getTenantId();
+      return `${this.getHostUrl()}/o/${tenantId}/projects/p/${sessionId}/r/${run.id}?poll=true`;
+    } else if (runId !== void 0) {
+      const run_ = await this.readRun(runId);
+      if (!run_.app_path) {
+        throw new Error(`Run ${runId} has no app_path`);
+      }
+      const baseUrl = this.getHostUrl();
+      return `${baseUrl}${run_.app_path}`;
+    } else {
+      throw new Error("Must provide either runId or run");
+    }
+  }
+  async _loadChildRuns(run) {
+    const childRuns = await toArray(this.listRuns({ id: run.child_run_ids }));
+    const treemap = {};
+    const runs = {};
+    childRuns.sort((a, b) => {
+      var _a, _b;
+      return ((_a = a == null ? void 0 : a.dotted_order) != null ? _a : "").localeCompare((_b = b == null ? void 0 : b.dotted_order) != null ? _b : "");
+    });
+    for (const childRun of childRuns) {
+      if (childRun.parent_run_id === null || childRun.parent_run_id === void 0) {
+        throw new Error(`Child run ${childRun.id} has no parent`);
+      }
+      if (!(childRun.parent_run_id in treemap)) {
+        treemap[childRun.parent_run_id] = [];
+      }
+      treemap[childRun.parent_run_id].push(childRun);
+      runs[childRun.id] = childRun;
+    }
+    run.child_runs = treemap[run.id] || [];
+    for (const runId in treemap) {
+      if (runId !== run.id) {
+        runs[runId].child_runs = treemap[runId];
+      }
+    }
+    return run;
+  }
+  /**
+   * List runs from the LangSmith server.
+   * @param projectId - The ID of the project to filter by.
+   * @param projectName - The name of the project to filter by.
+   * @param parentRunId - The ID of the parent run to filter by.
+   * @param traceId - The ID of the trace to filter by.
+   * @param referenceExampleId - The ID of the reference example to filter by.
+   * @param startTime - The start time to filter by.
+   * @param isRoot - Indicates whether to only return root runs.
+   * @param runType - The run type to filter by.
+   * @param error - Indicates whether to filter by error runs.
+   * @param id - The ID of the run to filter by.
+   * @param query - The query string to filter by.
+   * @param filter - The filter string to apply to the run spans.
+   * @param traceFilter - The filter string to apply on the root run of the trace.
+   * @param limit - The maximum number of runs to retrieve.
+   * @returns {AsyncIterable<Run>} - The runs.
+   *
+   * @example
+   * // List all runs in a project
+   * const projectRuns = client.listRuns({ projectName: "<your_project>" });
+   *
+   * @example
+   * // List LLM and Chat runs in the last 24 hours
+   * const todaysLLMRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   start_time: new Date(Date.now() - 24 * 60 * 60 * 1000),
+   *   run_type: "llm",
+   * });
+   *
+   * @example
+   * // List traces in a project
+   * const rootRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   execution_order: 1,
+   * });
+   *
+   * @example
+   * // List runs without errors
+   * const correctRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   error: false,
+   * });
+   *
+   * @example
+   * // List runs by run ID
+   * const runIds = [
+   *   "a36092d2-4ad5-4fb4-9c0d-0dba9a2ed836",
+   *   "9398e6be-964f-4aa4-8ae9-ad78cd4b7074",
+   * ];
+   * const selectedRuns = client.listRuns({ run_ids: runIds });
+   *
+   * @example
+   * // List all "chain" type runs that took more than 10 seconds and had `total_tokens` greater than 5000
+   * const chainRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(eq(run_type, "chain"), gt(latency, 10), gt(total_tokens, 5000))',
+   * });
+   *
+   * @example
+   * // List all runs called "extractor" whose root of the trace was assigned feedback "user_score" score of 1
+   * const goodExtractorRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'eq(name, "extractor")',
+   *   traceFilter: 'and(eq(feedback_key, "user_score"), eq(feedback_score, 1))',
+   * });
+   *
+   * @example
+   * // List all runs that started after a specific timestamp and either have "error" not equal to null or a "Correctness" feedback score equal to 0
+   * const complexRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(gt(start_time, "2023-07-15T12:34:56Z"), or(neq(error, null), and(eq(feedback_key, "Correctness"), eq(feedback_score, 0.0))))',
+   * });
+   *
+   * @example
+   * // List all runs where `tags` include "experimental" or "beta" and `latency` is greater than 2 seconds
+   * const taggedRuns = client.listRuns({
+   *   projectName: "<your_project>",
+   *   filter: 'and(or(has(tags, "experimental"), has(tags, "beta")), gt(latency, 2))',
+   * });
+   */
+  listRuns(props) {
+    return __asyncGenerator(this, null, function* () {
+      const { projectId, projectName, parentRunId, traceId, referenceExampleId, startTime, executionOrder, isRoot, runType, error, id, query, filter, traceFilter, treeFilter, limit, select } = props;
+      let projectIds = [];
+      if (projectId) {
+        projectIds = Array.isArray(projectId) ? projectId : [projectId];
+      }
+      if (projectName) {
+        const projectNames = Array.isArray(projectName) ? projectName : [projectName];
+        const projectIds_ = yield new __await(Promise.all(projectNames.map((name) => this.readProject({ projectName: name }).then((project) => project.id))));
+        projectIds.push(...projectIds_);
+      }
+      const default_select = [
+        "app_path",
+        "child_run_ids",
+        "completion_cost",
+        "completion_tokens",
+        "dotted_order",
+        "end_time",
+        "error",
+        "events",
+        "extra",
+        "feedback_stats",
+        "first_token_time",
+        "id",
+        "inputs",
+        "name",
+        "outputs",
+        "parent_run_id",
+        "parent_run_ids",
+        "prompt_cost",
+        "prompt_tokens",
+        "reference_example_id",
+        "run_type",
+        "session_id",
+        "start_time",
+        "status",
+        "tags",
+        "total_cost",
+        "total_tokens",
+        "trace_id"
+      ];
+      const body = {
+        session: projectIds.length ? projectIds : null,
+        run_type: runType,
+        reference_example: referenceExampleId,
+        query,
+        filter,
+        trace_filter: traceFilter,
+        tree_filter: treeFilter,
+        execution_order: executionOrder,
+        parent_run: parentRunId,
+        start_time: startTime ? startTime.toISOString() : null,
+        error,
+        id,
+        limit,
+        trace: traceId,
+        select: select ? select : default_select,
+        is_root: isRoot
+      };
+      let runsYielded = 0;
+      try {
+        for (var iter = __forAwait(this._getCursorPaginatedList("/runs/query", body)), more, temp, error2; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const runs = temp.value;
+          if (limit) {
+            if (runsYielded >= limit) {
+              break;
+            }
+            if (runs.length + runsYielded > limit) {
+              const newRuns = runs.slice(0, limit - runsYielded);
+              yield* __yieldStar(newRuns);
+              break;
+            }
+            runsYielded += runs.length;
+            yield* __yieldStar(runs);
+          } else {
+            yield* __yieldStar(runs);
+          }
+        }
+      } catch (temp) {
+        error2 = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error2)
+            throw error2[0];
+        }
+      }
+    });
+  }
+  async shareRun(runId, { shareId } = {}) {
+    const data = {
+      run_id: runId,
+      share_token: shareId || v4_default()
+    };
+    assertUuid(runId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, __spreadValues({
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(data),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const result = await response.json();
+    if (result === null || !("share_token" in result)) {
+      throw new Error("Invalid response from server");
+    }
+    return `${this.getHostUrl()}/public/${result["share_token"]}/r`;
+  }
+  async unshareRun(runId) {
+    assertUuid(runId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "unshare run");
+  }
+  async readRunSharedLink(runId) {
+    assertUuid(runId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/runs/${runId}/share`, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const result = await response.json();
+    if (result === null || !("share_token" in result)) {
+      return void 0;
+    }
+    return `${this.getHostUrl()}/public/${result["share_token"]}/r`;
+  }
+  async listSharedRuns(shareToken, { runIds } = {}) {
+    const queryParams = new URLSearchParams({
+      share_token: shareToken
+    });
+    if (runIds !== void 0) {
+      for (const runId of runIds) {
+        queryParams.append("id", runId);
+      }
+    }
+    assertUuid(shareToken);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/public/${shareToken}/runs${queryParams}`, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const runs = await response.json();
+    return runs;
+  }
+  async readDatasetSharedSchema(datasetId, datasetName) {
+    if (!datasetId && !datasetName) {
+      throw new Error("Either datasetId or datasetName must be given");
+    }
+    if (!datasetId) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId = dataset.id;
+    }
+    assertUuid(datasetId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const shareSchema = await response.json();
+    shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
+    return shareSchema;
+  }
+  async shareDataset(datasetId, datasetName) {
+    if (!datasetId && !datasetName) {
+      throw new Error("Either datasetId or datasetName must be given");
+    }
+    if (!datasetId) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId = dataset.id;
+    }
+    const data = {
+      dataset_id: datasetId
+    };
+    assertUuid(datasetId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, __spreadValues({
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(data),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const shareSchema = await response.json();
+    shareSchema.url = `${this.getHostUrl()}/public/${shareSchema.share_token}/d`;
+    return shareSchema;
+  }
+  async unshareDataset(datasetId) {
+    assertUuid(datasetId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${datasetId}/share`, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "unshare dataset");
+  }
+  async readSharedDataset(shareToken) {
+    assertUuid(shareToken);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/public/${shareToken}/datasets`, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const dataset = await response.json();
+    return dataset;
+  }
+  async createProject({ projectName, description = null, metadata = null, upsert = false, projectExtra = null, referenceDatasetId = null }) {
+    const upsert_ = upsert ? `?upsert=true` : "";
+    const endpoint = `${this.apiUrl}/sessions${upsert_}`;
+    const extra = projectExtra || {};
+    if (metadata) {
+      extra["metadata"] = metadata;
+    }
+    const body = {
+      name: projectName,
+      extra,
+      description
+    };
+    if (referenceDatasetId !== null) {
+      body["reference_dataset_id"] = referenceDatasetId;
+    }
+    const response = await this.caller.call(fetch, endpoint, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const result = await response.json();
+    if (!response.ok) {
+      throw new Error(`Failed to create session ${projectName}: ${response.status} ${response.statusText}`);
+    }
+    return result;
+  }
+  async updateProject(projectId, { name = null, description = null, metadata = null, projectExtra = null, endTime = null }) {
+    const endpoint = `${this.apiUrl}/sessions/${projectId}`;
+    let extra = projectExtra;
+    if (metadata) {
+      extra = __spreadProps(__spreadValues({}, extra || {}), { metadata });
+    }
+    const body = {
+      name,
+      extra,
+      description,
+      end_time: endTime ? new Date(endTime).toISOString() : null
+    };
+    const response = await this.caller.call(fetch, endpoint, __spreadValues({
+      method: "PATCH",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const result = await response.json();
+    if (!response.ok) {
+      throw new Error(`Failed to update project ${projectId}: ${response.status} ${response.statusText}`);
+    }
+    return result;
+  }
+  async hasProject({ projectId, projectName }) {
+    let path = "/sessions";
+    const params = new URLSearchParams();
+    if (projectId !== void 0 && projectName !== void 0) {
+      throw new Error("Must provide either projectName or projectId, not both");
+    } else if (projectId !== void 0) {
+      assertUuid(projectId);
+      path += `/${projectId}`;
+    } else if (projectName !== void 0) {
+      params.append("name", projectName);
+    } else {
+      throw new Error("Must provide projectName or projectId");
+    }
+    const response = await this.caller.call(fetch, `${this.apiUrl}${path}?${params}`, __spreadValues({
+      method: "GET",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    try {
+      const result = await response.json();
+      if (!response.ok) {
+        return false;
+      }
+      if (Array.isArray(result)) {
+        return result.length > 0;
+      }
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  async readProject({ projectId, projectName, includeStats }) {
+    let path = "/sessions";
+    const params = new URLSearchParams();
+    if (projectId !== void 0 && projectName !== void 0) {
+      throw new Error("Must provide either projectName or projectId, not both");
+    } else if (projectId !== void 0) {
+      assertUuid(projectId);
+      path += `/${projectId}`;
+    } else if (projectName !== void 0) {
+      params.append("name", projectName);
+    } else {
+      throw new Error("Must provide projectName or projectId");
+    }
+    if (includeStats !== void 0) {
+      params.append("include_stats", includeStats.toString());
+    }
+    const response = await this._get(path, params);
+    let result;
+    if (Array.isArray(response)) {
+      if (response.length === 0) {
+        throw new Error(`Project[id=${projectId}, name=${projectName}] not found`);
+      }
+      result = response[0];
+    } else {
+      result = response;
+    }
+    return result;
+  }
+  async getProjectUrl({ projectId, projectName }) {
+    if (projectId === void 0 && projectName === void 0) {
+      throw new Error("Must provide either projectName or projectId");
+    }
+    const project = await this.readProject({ projectId, projectName });
+    const tenantId = await this._getTenantId();
+    return `${this.getHostUrl()}/o/${tenantId}/projects/p/${project.id}`;
+  }
+  async getDatasetUrl({ datasetId, datasetName }) {
+    if (datasetId === void 0 && datasetName === void 0) {
+      throw new Error("Must provide either datasetName or datasetId");
+    }
+    const dataset = await this.readDataset({ datasetId, datasetName });
+    const tenantId = await this._getTenantId();
+    return `${this.getHostUrl()}/o/${tenantId}/datasets/${dataset.id}`;
+  }
+  async _getTenantId() {
+    if (this._tenantId !== null) {
+      return this._tenantId;
+    }
+    const queryParams = new URLSearchParams({ limit: "1" });
+    try {
+      for (var iter = __forAwait(this._getPaginated("/sessions", queryParams)), more, temp, error; more = !(temp = await iter.next()).done; more = false) {
+        const projects = temp.value;
+        this._tenantId = projects[0].tenant_id;
+        return projects[0].tenant_id;
+      }
+    } catch (temp) {
+      error = [temp];
+    } finally {
+      try {
+        more && (temp = iter.return) && await temp.call(iter);
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+    throw new Error("No projects found to resolve tenant.");
+  }
+  listProjects() {
+    return __asyncGenerator(this, arguments, function* ({ projectIds, name, nameContains, referenceDatasetId, referenceDatasetName, referenceFree } = {}) {
+      const params = new URLSearchParams();
+      if (projectIds !== void 0) {
+        for (const projectId of projectIds) {
+          params.append("id", projectId);
+        }
+      }
+      if (name !== void 0) {
+        params.append("name", name);
+      }
+      if (nameContains !== void 0) {
+        params.append("name_contains", nameContains);
+      }
+      if (referenceDatasetId !== void 0) {
+        params.append("reference_dataset", referenceDatasetId);
+      } else if (referenceDatasetName !== void 0) {
+        const dataset = yield new __await(this.readDataset({
+          datasetName: referenceDatasetName
+        }));
+        params.append("reference_dataset", dataset.id);
+      }
+      if (referenceFree !== void 0) {
+        params.append("reference_free", referenceFree.toString());
+      }
+      try {
+        for (var iter = __forAwait(this._getPaginated("/sessions", params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const projects = temp.value;
+          yield* __yieldStar(projects);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  async deleteProject({ projectId, projectName }) {
+    let projectId_;
+    if (projectId === void 0 && projectName === void 0) {
+      throw new Error("Must provide projectName or projectId");
+    } else if (projectId !== void 0 && projectName !== void 0) {
+      throw new Error("Must provide either projectName or projectId, not both");
+    } else if (projectId === void 0) {
+      projectId_ = (await this.readProject({ projectName })).id;
+    } else {
+      projectId_ = projectId;
+    }
+    assertUuid(projectId_);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/sessions/${projectId_}`, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, `delete session ${projectId_} (${projectName})`);
+  }
+  async uploadCsv({ csvFile, fileName, inputKeys, outputKeys, description, dataType, name }) {
+    const url = `${this.apiUrl}/datasets/upload`;
+    const formData = new FormData();
+    formData.append("file", csvFile, fileName);
+    inputKeys.forEach((key) => {
+      formData.append("input_keys", key);
+    });
+    outputKeys.forEach((key) => {
+      formData.append("output_keys", key);
+    });
+    if (description) {
+      formData.append("description", description);
+    }
+    if (dataType) {
+      formData.append("data_type", dataType);
+    }
+    if (name) {
+      formData.append("name", name);
+    }
+    const response = await this.caller.call(fetch, url, __spreadValues({
+      method: "POST",
+      headers: this.headers,
+      body: formData,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      const result2 = await response.json();
+      if (result2.detail && result2.detail.includes("already exists")) {
+        throw new Error(`Dataset ${fileName} already exists`);
+      }
+      throw new Error(`Failed to upload CSV: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+  }
+  async createDataset(name, { description, dataType } = {}) {
+    const body = {
+      name,
+      description
+    };
+    if (dataType) {
+      body.data_type = dataType;
+    }
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets`, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      const result2 = await response.json();
+      if (result2.detail && result2.detail.includes("already exists")) {
+        throw new Error(`Dataset ${name} already exists`);
+      }
+      throw new Error(`Failed to create dataset ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+  }
+  async readDataset({ datasetId, datasetName }) {
+    let path = "/datasets";
+    const params = new URLSearchParams({ limit: "1" });
+    if (datasetId !== void 0 && datasetName !== void 0) {
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    } else if (datasetId !== void 0) {
+      assertUuid(datasetId);
+      path += `/${datasetId}`;
+    } else if (datasetName !== void 0) {
+      params.append("name", datasetName);
+    } else {
+      throw new Error("Must provide datasetName or datasetId");
+    }
+    const response = await this._get(path, params);
+    let result;
+    if (Array.isArray(response)) {
+      if (response.length === 0) {
+        throw new Error(`Dataset[id=${datasetId}, name=${datasetName}] not found`);
+      }
+      result = response[0];
+    } else {
+      result = response;
+    }
+    return result;
+  }
+  async hasDataset({ datasetId, datasetName }) {
+    try {
+      await this.readDataset({ datasetId, datasetName });
+      return true;
+    } catch (e) {
+      if (
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        e instanceof Error && e.message.toLocaleLowerCase().includes("not found")
+      ) {
+        return false;
+      }
+      throw e;
+    }
+  }
+  async diffDatasetVersions({ datasetId, datasetName, fromVersion, toVersion }) {
+    let datasetId_ = datasetId;
+    if (datasetId_ === void 0 && datasetName === void 0) {
+      throw new Error("Must provide either datasetName or datasetId");
+    } else if (datasetId_ !== void 0 && datasetName !== void 0) {
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    } else if (datasetId_ === void 0) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId_ = dataset.id;
+    }
+    const urlParams = new URLSearchParams({
+      from_version: typeof fromVersion === "string" ? fromVersion : fromVersion.toISOString(),
+      to_version: typeof toVersion === "string" ? toVersion : toVersion.toISOString()
+    });
+    const response = await this._get(`/datasets/${datasetId_}/versions/diff`, urlParams);
+    return response;
+  }
+  async readDatasetOpenaiFinetuning({ datasetId, datasetName }) {
+    const path = "/datasets";
+    if (datasetId !== void 0) {
+    } else if (datasetName !== void 0) {
+      datasetId = (await this.readDataset({ datasetName })).id;
+    } else {
+      throw new Error("Must provide datasetName or datasetId");
+    }
+    const response = await this._getResponse(`${path}/${datasetId}/openai_ft`);
+    const datasetText = await response.text();
+    const dataset = datasetText.trim().split("\n").map((line) => JSON.parse(line));
+    return dataset;
+  }
+  listDatasets() {
+    return __asyncGenerator(this, arguments, function* ({ limit = 100, offset = 0, datasetIds, datasetName, datasetNameContains } = {}) {
+      const path = "/datasets";
+      const params = new URLSearchParams({
+        limit: limit.toString(),
+        offset: offset.toString()
+      });
+      if (datasetIds !== void 0) {
+        for (const id_ of datasetIds) {
+          params.append("id", id_);
+        }
+      }
+      if (datasetName !== void 0) {
+        params.append("name", datasetName);
+      }
+      if (datasetNameContains !== void 0) {
+        params.append("name_contains", datasetNameContains);
+      }
+      try {
+        for (var iter = __forAwait(this._getPaginated(path, params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const datasets = temp.value;
+          yield* __yieldStar(datasets);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  /**
+   * Update a dataset
+   * @param props The dataset details to update
+   * @returns The updated dataset
+   */
+  async updateDataset(props) {
+    const _a = props, { datasetId, datasetName } = _a, update = __objRest(_a, ["datasetId", "datasetName"]);
+    if (!datasetId && !datasetName) {
+      throw new Error("Must provide either datasetName or datasetId");
+    }
+    const _datasetId = datasetId != null ? datasetId : (await this.readDataset({ datasetName })).id;
+    assertUuid(_datasetId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/${_datasetId}`, __spreadValues({
+      method: "PATCH",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(update),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to update dataset ${_datasetId}: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+  }
+  async deleteDataset({ datasetId, datasetName }) {
+    let path = "/datasets";
+    let datasetId_ = datasetId;
+    if (datasetId !== void 0 && datasetName !== void 0) {
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    } else if (datasetName !== void 0) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId_ = dataset.id;
+    }
+    if (datasetId_ !== void 0) {
+      assertUuid(datasetId_);
+      path += `/${datasetId_}`;
+    } else {
+      throw new Error("Must provide datasetName or datasetId");
+    }
+    const response = await this.caller.call(fetch, this.apiUrl + path, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`);
+    }
+    await response.json();
+  }
+  async createExample(inputs, outputs, { datasetId, datasetName, createdAt, exampleId, metadata, split }) {
+    let datasetId_ = datasetId;
+    if (datasetId_ === void 0 && datasetName === void 0) {
+      throw new Error("Must provide either datasetName or datasetId");
+    } else if (datasetId_ !== void 0 && datasetName !== void 0) {
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    } else if (datasetId_ === void 0) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId_ = dataset.id;
+    }
+    const createdAt_ = createdAt || /* @__PURE__ */ new Date();
+    const data = {
+      dataset_id: datasetId_,
+      inputs,
+      outputs,
+      created_at: createdAt_ == null ? void 0 : createdAt_.toISOString(),
+      id: exampleId,
+      metadata,
+      split
+    };
+    const response = await this.caller.call(fetch, `${this.apiUrl}/examples`, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(data),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to create example: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+  }
+  async createExamples(props) {
+    const { inputs, outputs, metadata, sourceRunIds, exampleIds, datasetId, datasetName } = props;
+    let datasetId_ = datasetId;
+    if (datasetId_ === void 0 && datasetName === void 0) {
+      throw new Error("Must provide either datasetName or datasetId");
+    } else if (datasetId_ !== void 0 && datasetName !== void 0) {
+      throw new Error("Must provide either datasetName or datasetId, not both");
+    } else if (datasetId_ === void 0) {
+      const dataset = await this.readDataset({ datasetName });
+      datasetId_ = dataset.id;
+    }
+    const formattedExamples = inputs.map((input, idx) => {
+      return {
+        dataset_id: datasetId_,
+        inputs: input,
+        outputs: outputs ? outputs[idx] : void 0,
+        metadata: metadata ? metadata[idx] : void 0,
+        split: props.splits ? props.splits[idx] : void 0,
+        id: exampleIds ? exampleIds[idx] : void 0,
+        source_run_id: sourceRunIds ? sourceRunIds[idx] : void 0
+      };
+    });
+    const response = await this.caller.call(fetch, `${this.apiUrl}/examples/bulk`, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(formattedExamples),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to create examples: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+  }
+  async createLLMExample(input, generation, options) {
+    return this.createExample({ input }, { output: generation }, options);
+  }
+  async createChatExample(input, generations, options) {
+    const finalInput = input.map((message) => {
+      if (isLangChainMessage(message)) {
+        return convertLangChainMessageToExample(message);
+      }
+      return message;
+    });
+    const finalOutput = isLangChainMessage(generations) ? convertLangChainMessageToExample(generations) : generations;
+    return this.createExample({ input: finalInput }, { output: finalOutput }, options);
+  }
+  async readExample(exampleId) {
+    assertUuid(exampleId);
+    const path = `/examples/${exampleId}`;
+    return await this._get(path);
+  }
+  listExamples() {
+    return __asyncGenerator(this, arguments, function* ({ datasetId, datasetName, exampleIds, asOf, splits, inlineS3Urls, metadata, limit, offset, filter } = {}) {
+      let datasetId_;
+      if (datasetId !== void 0 && datasetName !== void 0) {
+        throw new Error("Must provide either datasetName or datasetId, not both");
+      } else if (datasetId !== void 0) {
+        datasetId_ = datasetId;
+      } else if (datasetName !== void 0) {
+        const dataset = yield new __await(this.readDataset({ datasetName }));
+        datasetId_ = dataset.id;
+      } else {
+        throw new Error("Must provide a datasetName or datasetId");
+      }
+      const params = new URLSearchParams({ dataset: datasetId_ });
+      const dataset_version = asOf ? typeof asOf === "string" ? asOf : asOf == null ? void 0 : asOf.toISOString() : void 0;
+      if (dataset_version) {
+        params.append("as_of", dataset_version);
+      }
+      const inlineS3Urls_ = inlineS3Urls != null ? inlineS3Urls : true;
+      params.append("inline_s3_urls", inlineS3Urls_.toString());
+      if (exampleIds !== void 0) {
+        for (const id_ of exampleIds) {
+          params.append("id", id_);
+        }
+      }
+      if (splits !== void 0) {
+        for (const split of splits) {
+          params.append("splits", split);
+        }
+      }
+      if (metadata !== void 0) {
+        const serializedMetadata = JSON.stringify(metadata);
+        params.append("metadata", serializedMetadata);
+      }
+      if (limit !== void 0) {
+        params.append("limit", limit.toString());
+      }
+      if (offset !== void 0) {
+        params.append("offset", offset.toString());
+      }
+      if (filter !== void 0) {
+        params.append("filter", filter);
+      }
+      let i = 0;
+      try {
+        for (var iter = __forAwait(this._getPaginated("/examples", params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const examples = temp.value;
+          for (const example of examples) {
+            yield example;
+            i++;
+          }
+          if (limit !== void 0 && i >= limit) {
+            break;
+          }
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  async deleteExample(exampleId) {
+    assertUuid(exampleId);
+    const path = `/examples/${exampleId}`;
+    const response = await this.caller.call(fetch, this.apiUrl + path, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`);
+    }
+    await response.json();
+  }
+  async updateExample(exampleId, update) {
+    assertUuid(exampleId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/examples/${exampleId}`, __spreadValues({
+      method: "PATCH",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(update),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to update example ${exampleId}: ${response.status} ${response.statusText}`);
+    }
+    const result = await response.json();
+    return result;
+  }
+  /**
+   * @deprecated This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.
+   */
+  async evaluateRun(run, evaluator, { sourceInfo, loadChildRuns, referenceExample } = { loadChildRuns: false }) {
+    warnOnce("This method is deprecated and will be removed in future LangSmith versions, use `evaluate` from `langsmith/evaluation` instead.");
+    let run_;
+    if (typeof run === "string") {
+      run_ = await this.readRun(run, { loadChildRuns });
+    } else if (typeof run === "object" && "id" in run) {
+      run_ = run;
+    } else {
+      throw new Error(`Invalid run type: ${typeof run}`);
+    }
+    if (run_.reference_example_id !== null && run_.reference_example_id !== void 0) {
+      referenceExample = await this.readExample(run_.reference_example_id);
+    }
+    const feedbackResult = await evaluator.evaluateRun(run_, referenceExample);
+    const [_, feedbacks] = await this._logEvaluationFeedback(feedbackResult, run_, sourceInfo);
+    return feedbacks[0];
+  }
+  async createFeedback(runId, key, { score, value, correction, comment, sourceInfo, feedbackSourceType = "api", sourceRunId, feedbackId, feedbackConfig, projectId, comparativeExperimentId }) {
+    var _a;
+    if (!runId && !projectId) {
+      throw new Error("One of runId or projectId must be provided");
+    }
+    if (runId && projectId) {
+      throw new Error("Only one of runId or projectId can be provided");
+    }
+    const feedback_source = {
+      type: feedbackSourceType != null ? feedbackSourceType : "api",
+      metadata: sourceInfo != null ? sourceInfo : {}
+    };
+    if (sourceRunId !== void 0 && (feedback_source == null ? void 0 : feedback_source.metadata) !== void 0 && !feedback_source.metadata["__run"]) {
+      feedback_source.metadata["__run"] = { run_id: sourceRunId };
+    }
+    if ((feedback_source == null ? void 0 : feedback_source.metadata) !== void 0 && ((_a = feedback_source.metadata["__run"]) == null ? void 0 : _a.run_id) !== void 0) {
+      assertUuid(feedback_source.metadata["__run"].run_id);
+    }
+    const feedback = {
+      id: feedbackId != null ? feedbackId : v4_default(),
+      run_id: runId,
+      key,
+      score,
+      value,
+      correction,
+      comment,
+      feedback_source,
+      comparative_experiment_id: comparativeExperimentId,
+      feedbackConfig,
+      session_id: projectId
+    };
+    const url = `${this.apiUrl}/feedback`;
+    const response = await this.caller.call(fetch, url, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(feedback),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "create feedback");
+    return feedback;
+  }
+  async updateFeedback(feedbackId, { score, value, correction, comment }) {
+    const feedbackUpdate = {};
+    if (score !== void 0 && score !== null) {
+      feedbackUpdate["score"] = score;
+    }
+    if (value !== void 0 && value !== null) {
+      feedbackUpdate["value"] = value;
+    }
+    if (correction !== void 0 && correction !== null) {
+      feedbackUpdate["correction"] = correction;
+    }
+    if (comment !== void 0 && comment !== null) {
+      feedbackUpdate["comment"] = comment;
+    }
+    assertUuid(feedbackId);
+    const response = await this.caller.call(fetch, `${this.apiUrl}/feedback/${feedbackId}`, __spreadValues({
+      method: "PATCH",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(feedbackUpdate),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    await raiseForStatus(response, "update feedback");
+  }
+  async readFeedback(feedbackId) {
+    assertUuid(feedbackId);
+    const path = `/feedback/${feedbackId}`;
+    const response = await this._get(path);
+    return response;
+  }
+  async deleteFeedback(feedbackId) {
+    assertUuid(feedbackId);
+    const path = `/feedback/${feedbackId}`;
+    const response = await this.caller.call(fetch, this.apiUrl + path, __spreadValues({
+      method: "DELETE",
+      headers: this.headers,
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${path}: ${response.status} ${response.statusText}`);
+    }
+    await response.json();
+  }
+  listFeedback() {
+    return __asyncGenerator(this, arguments, function* ({ runIds, feedbackKeys, feedbackSourceTypes } = {}) {
+      const queryParams = new URLSearchParams();
+      if (runIds) {
+        queryParams.append("run", runIds.join(","));
+      }
+      if (feedbackKeys) {
+        for (const key of feedbackKeys) {
+          queryParams.append("key", key);
+        }
+      }
+      if (feedbackSourceTypes) {
+        for (const type of feedbackSourceTypes) {
+          queryParams.append("source", type);
+        }
+      }
+      try {
+        for (var iter = __forAwait(this._getPaginated("/feedback", queryParams)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const feedbacks = temp.value;
+          yield* __yieldStar(feedbacks);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  /**
+   * Creates a presigned feedback token and URL.
+   *
+   * The token can be used to authorize feedback metrics without
+   * needing an API key. This is useful for giving browser-based
+   * applications the ability to submit feedback without needing
+   * to expose an API key.
+   *
+   * @param runId - The ID of the run.
+   * @param feedbackKey - The feedback key.
+   * @param options - Additional options for the token.
+   * @param options.expiration - The expiration time for the token.
+   *
+   * @returns A promise that resolves to a FeedbackIngestToken.
+   */
+  async createPresignedFeedbackToken(runId, feedbackKey, { expiration, feedbackConfig } = {}) {
+    const body = {
+      run_id: runId,
+      feedback_key: feedbackKey,
+      feedback_config: feedbackConfig
+    };
+    if (expiration) {
+      if (typeof expiration === "string") {
+        body["expires_at"] = expiration;
+      } else if ((expiration == null ? void 0 : expiration.hours) || (expiration == null ? void 0 : expiration.minutes) || (expiration == null ? void 0 : expiration.days)) {
+        body["expires_in"] = expiration;
+      }
+    } else {
+      body["expires_in"] = {
+        hours: 3
+      };
+    }
+    const response = await this.caller.call(fetch, `${this.apiUrl}/feedback/tokens`, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    const result = await response.json();
+    return result;
+  }
+  async createComparativeExperiment({ name, experimentIds, referenceDatasetId, createdAt, description, metadata, id }) {
+    var _a;
+    if (experimentIds.length === 0) {
+      throw new Error("At least one experiment is required");
+    }
+    if (!referenceDatasetId) {
+      referenceDatasetId = (await this.readProject({
+        projectId: experimentIds[0]
+      })).reference_dataset_id;
+    }
+    if (!referenceDatasetId == null) {
+      throw new Error("A reference dataset is required");
+    }
+    const body = {
+      id,
+      name,
+      experiment_ids: experimentIds,
+      reference_dataset_id: referenceDatasetId,
+      description,
+      created_at: (_a = createdAt != null ? createdAt : /* @__PURE__ */ new Date()) == null ? void 0 : _a.toISOString(),
+      extra: {}
+    };
+    if (metadata)
+      body.extra["metadata"] = metadata;
+    const response = await this.caller.call(fetch, `${this.apiUrl}/datasets/comparative`, __spreadValues({
+      method: "POST",
+      headers: __spreadProps(__spreadValues({}, this.headers), { "Content-Type": "application/json" }),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout_ms)
+    }, this.fetchOptions));
+    return await response.json();
+  }
+  /**
+   * Retrieves a list of presigned feedback tokens for a given run ID.
+   * @param runId The ID of the run.
+   * @returns An async iterable of FeedbackIngestToken objects.
+   */
+  listPresignedFeedbackTokens(runId) {
+    return __asyncGenerator(this, null, function* () {
+      assertUuid(runId);
+      const params = new URLSearchParams({ run_id: runId });
+      try {
+        for (var iter = __forAwait(this._getPaginated("/feedback/tokens", params)), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+          const tokens = temp.value;
+          yield* __yieldStar(tokens);
+        }
+      } catch (temp) {
+        error = [temp];
+      } finally {
+        try {
+          more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+        } finally {
+          if (error)
+            throw error[0];
+        }
+      }
+    });
+  }
+  _selectEvalResults(results) {
+    let results_;
+    if ("results" in results) {
+      results_ = results.results;
+    } else {
+      results_ = [results];
+    }
+    return results_;
+  }
+  async _logEvaluationFeedback(evaluatorResponse, run, sourceInfo) {
+    const evalResults = this._selectEvalResults(evaluatorResponse);
+    const feedbacks = [];
+    for (const res of evalResults) {
+      let sourceInfo_ = sourceInfo || {};
+      if (res.evaluatorInfo) {
+        sourceInfo_ = __spreadValues(__spreadValues({}, res.evaluatorInfo), sourceInfo_);
+      }
+      let runId_ = null;
+      if (res.targetRunId) {
+        runId_ = res.targetRunId;
+      } else if (run) {
+        runId_ = run.id;
+      }
+      feedbacks.push(await this.createFeedback(runId_, res.key, {
+        score: res.score,
+        value: res.value,
+        comment: res.comment,
+        correction: res.correction,
+        sourceInfo: sourceInfo_,
+        sourceRunId: res.sourceRunId,
+        feedbackConfig: res.feedbackConfig,
+        feedbackSourceType: "model"
+      }));
+    }
+    return [evalResults, feedbacks];
+  }
+  async logEvaluationFeedback(evaluatorResponse, run, sourceInfo) {
+    const [results] = await this._logEvaluationFeedback(evaluatorResponse, run, sourceInfo);
+    return results;
+  }
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/index.js
+var __version__ = "0.1.36";
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/env.js
+var globalEnv;
+var isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+var isWebWorker = () => typeof globalThis === "object" && globalThis.constructor && globalThis.constructor.name === "DedicatedWorkerGlobalScope";
+var isJsDom = () => typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom"));
+var isDeno = () => typeof Deno !== "undefined";
+var isNode = () => typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined" && !isDeno();
+var getEnv = () => {
+  if (globalEnv) {
+    return globalEnv;
+  }
+  if (isBrowser()) {
+    globalEnv = "browser";
+  } else if (isNode()) {
+    globalEnv = "node";
+  } else if (isWebWorker()) {
+    globalEnv = "webworker";
+  } else if (isJsDom()) {
+    globalEnv = "jsdom";
+  } else if (isDeno()) {
+    globalEnv = "deno";
+  } else {
+    globalEnv = "other";
+  }
+  return globalEnv;
 };
-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 });
+var runtimeEnvironment;
+async function getRuntimeEnvironment() {
+  if (runtimeEnvironment === void 0) {
+    const env = getEnv();
+    const releaseEnv = getShas();
+    runtimeEnvironment = __spreadValues({
+      library: "langsmith",
+      runtime: env,
+      sdk: "langsmith-js",
+      sdk_version: __version__
+    }, releaseEnv);
   }
-  return to;
+  return runtimeEnvironment;
+}
+function getLangChainEnvVarsMetadata() {
+  const allEnvVars = getEnvironmentVariables() || {};
+  const envVars = {};
+  const excluded = [
+    "LANGCHAIN_API_KEY",
+    "LANGCHAIN_ENDPOINT",
+    "LANGCHAIN_TRACING_V2",
+    "LANGCHAIN_PROJECT",
+    "LANGCHAIN_SESSION"
+  ];
+  for (const [key, value] of Object.entries(allEnvVars)) {
+    if (key.startsWith("LANGCHAIN_") && typeof value === "string" && !excluded.includes(key) && !key.toLowerCase().includes("key") && !key.toLowerCase().includes("secret") && !key.toLowerCase().includes("token")) {
+      if (key === "LANGCHAIN_REVISION_ID") {
+        envVars["revision_id"] = value;
+      } else {
+        envVars[key] = value;
+      }
+    }
+  }
+  return envVars;
+}
+function getEnvironmentVariables() {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      return Object.entries(process.env).reduce((acc, [key, value]) => {
+        acc[key] = String(value);
+        return acc;
+      }, {});
+    }
+    return void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function getEnvironmentVariable(name) {
+  var _a;
+  try {
+    return typeof process !== "undefined" ? (
+      // eslint-disable-next-line no-process-env
+      (_a = process.env) == null ? void 0 : _a[name]
+    ) : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+var cachedCommitSHAs;
+function getShas() {
+  if (cachedCommitSHAs !== void 0) {
+    return cachedCommitSHAs;
+  }
+  const common_release_envs = [
+    "VERCEL_GIT_COMMIT_SHA",
+    "NEXT_PUBLIC_VERCEL_GIT_COMMIT_SHA",
+    "COMMIT_REF",
+    "RENDER_GIT_COMMIT",
+    "CI_COMMIT_SHA",
+    "CIRCLE_SHA1",
+    "CF_PAGES_COMMIT_SHA",
+    "REACT_APP_GIT_SHA",
+    "SOURCE_VERSION",
+    "GITHUB_SHA",
+    "TRAVIS_COMMIT",
+    "GIT_COMMIT",
+    "BUILD_VCS_NUMBER",
+    "bamboo_planRepository_revision",
+    "Build.SourceVersion",
+    "BITBUCKET_COMMIT",
+    "DRONE_COMMIT_SHA",
+    "SEMAPHORE_GIT_SHA",
+    "BUILDKITE_COMMIT"
+  ];
+  const shas = {};
+  for (const env of common_release_envs) {
+    const envVar = getEnvironmentVariable(env);
+    if (envVar !== void 0) {
+      shas[env] = envVar;
+    }
+  }
+  cachedCommitSHAs = shas;
+  return shas;
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/env.js
+var isTracingEnabled = (tracingEnabled) => {
+  if (tracingEnabled !== void 0) {
+    return tracingEnabled;
+  }
+  const envVars = [
+    "LANGSMITH_TRACING_V2",
+    "LANGCHAIN_TRACING_V2",
+    "LANGSMITH_TRACING",
+    "LANGCHAIN_TRACING"
+  ];
+  return !!envVars.find((envVar) => getEnvironmentVariable(envVar) === "true");
 };
-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);
 
-// src/ai-model/index.ts
-var ai_model_exports = {};
-__export(ai_model_exports, {
-  AiExtractElementInfo: () => AiExtractElementInfo,
-  AiInspectElement: () => AiInspectElement,
-  callToGetJSONObject: () => callToGetJSONObject,
-  describeUserPage: () => describeUserPage,
-  systemPromptToFindElement: () => systemPromptToFindElement
-});
-module.exports = __toCommonJS(ai_model_exports);
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/run_trees.js
+function stripNonAlphanumeric(input) {
+  return input.replace(/[-:.]/g, "");
+}
+function convertToDottedOrderFormat(epoch, runId, executionOrder = 1) {
+  const paddedOrder = executionOrder.toFixed(0).slice(0, 3).padStart(3, "0");
+  return stripNonAlphanumeric(`${new Date(epoch).toISOString().slice(0, -1)}${paddedOrder}Z`) + runId;
+}
+var Baggage = class _Baggage {
+  constructor(metadata, tags) {
+    Object.defineProperty(this, "metadata", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "tags", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.metadata = metadata;
+    this.tags = tags;
+  }
+  static fromHeader(value) {
+    const items = value.split(",");
+    let metadata = {};
+    let tags = [];
+    for (const item of items) {
+      const [key, uriValue] = item.split("=");
+      const value2 = decodeURIComponent(uriValue);
+      if (key === "langsmith-metadata") {
+        metadata = JSON.parse(value2);
+      } else if (key === "langsmith-tags") {
+        tags = value2.split(",");
+      }
+    }
+    return new _Baggage(metadata, tags);
+  }
+  toHeader() {
+    const items = [];
+    if (this.metadata && Object.keys(this.metadata).length > 0) {
+      items.push(`langsmith-metadata=${encodeURIComponent(JSON.stringify(this.metadata))}`);
+    }
+    if (this.tags && this.tags.length > 0) {
+      items.push(`langsmith-tags=${encodeURIComponent(this.tags.join(","))}`);
+    }
+    return items.join(",");
+  }
+};
+var RunTree = class _RunTree {
+  constructor(originalConfig) {
+    var _b, _c, _d, _e, _f;
+    Object.defineProperty(this, "id", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "run_type", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "project_name", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "parent_run", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "child_runs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "start_time", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "end_time", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "extra", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "tags", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "error", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "serialized", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "inputs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "outputs", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "reference_example_id", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "events", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "trace_id", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dotted_order", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "tracingEnabled", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "execution_order", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "child_execution_order", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    const defaultConfig = _RunTree.getDefaultConfig();
+    const _a = originalConfig, { metadata } = _a, config = __objRest(_a, ["metadata"]);
+    const client = (_b = config.client) != null ? _b : new Client();
+    const dedupedMetadata = __spreadValues(__spreadValues({}, metadata), (_c = config == null ? void 0 : config.extra) == null ? void 0 : _c.metadata);
+    config.extra = __spreadProps(__spreadValues({}, config.extra), { metadata: dedupedMetadata });
+    Object.assign(this, __spreadProps(__spreadValues(__spreadValues({}, defaultConfig), config), { client }));
+    if (!this.trace_id) {
+      if (this.parent_run) {
+        this.trace_id = (_d = this.parent_run.trace_id) != null ? _d : this.id;
+      } else {
+        this.trace_id = this.id;
+      }
+    }
+    (_e = this.execution_order) != null ? _e : this.execution_order = 1;
+    (_f = this.child_execution_order) != null ? _f : this.child_execution_order = 1;
+    if (!this.dotted_order) {
+      const currentDottedOrder = convertToDottedOrderFormat(this.start_time, this.id, this.execution_order);
+      if (this.parent_run) {
+        this.dotted_order = this.parent_run.dotted_order + "." + currentDottedOrder;
+      } else {
+        this.dotted_order = currentDottedOrder;
+      }
+    }
+  }
+  static getDefaultConfig() {
+    var _a, _b, _c;
+    return {
+      id: v4_default(),
+      run_type: "chain",
+      project_name: (_b = (_a = getEnvironmentVariable("LANGCHAIN_PROJECT")) != null ? _a : getEnvironmentVariable("LANGCHAIN_SESSION")) != null ? _b : (
+        // TODO: Deprecate
+        "default"
+      ),
+      child_runs: [],
+      api_url: (_c = getEnvironmentVariable("LANGCHAIN_ENDPOINT")) != null ? _c : "http://localhost:1984",
+      api_key: getEnvironmentVariable("LANGCHAIN_API_KEY"),
+      caller_options: {},
+      start_time: Date.now(),
+      serialized: {},
+      inputs: {},
+      extra: {}
+    };
+  }
+  createChild(config) {
+    const child_execution_order = this.child_execution_order + 1;
+    const child = new _RunTree(__spreadProps(__spreadValues({}, config), {
+      parent_run: this,
+      project_name: this.project_name,
+      client: this.client,
+      tracingEnabled: this.tracingEnabled,
+      execution_order: child_execution_order,
+      child_execution_order
+    }));
+    const visited = /* @__PURE__ */ new Set();
+    let current = this;
+    while (current != null && !visited.has(current.id)) {
+      visited.add(current.id);
+      current.child_execution_order = Math.max(current.child_execution_order, child_execution_order);
+      current = current.parent_run;
+    }
+    this.child_runs.push(child);
+    return child;
+  }
+  async end(outputs, error, endTime = Date.now()) {
+    var _a, _b, _c;
+    this.outputs = (_a = this.outputs) != null ? _a : outputs;
+    this.error = (_b = this.error) != null ? _b : error;
+    this.end_time = (_c = this.end_time) != null ? _c : endTime;
+  }
+  _convertToCreate(run, runtimeEnv, excludeChildRuns = true) {
+    var _a, _b;
+    const runExtra = (_a = run.extra) != null ? _a : {};
+    if (!runExtra.runtime) {
+      runExtra.runtime = {};
+    }
+    if (runtimeEnv) {
+      for (const [k, v] of Object.entries(runtimeEnv)) {
+        if (!runExtra.runtime[k]) {
+          runExtra.runtime[k] = v;
+        }
+      }
+    }
+    let child_runs;
+    let parent_run_id;
+    if (!excludeChildRuns) {
+      child_runs = run.child_runs.map((child_run) => this._convertToCreate(child_run, runtimeEnv, excludeChildRuns));
+      parent_run_id = void 0;
+    } else {
+      parent_run_id = (_b = run.parent_run) == null ? void 0 : _b.id;
+      child_runs = [];
+    }
+    const persistedRun = {
+      id: run.id,
+      name: run.name,
+      start_time: run.start_time,
+      end_time: run.end_time,
+      run_type: run.run_type,
+      reference_example_id: run.reference_example_id,
+      extra: runExtra,
+      serialized: run.serialized,
+      error: run.error,
+      inputs: run.inputs,
+      outputs: run.outputs,
+      session_name: run.project_name,
+      child_runs,
+      parent_run_id,
+      trace_id: run.trace_id,
+      dotted_order: run.dotted_order,
+      tags: run.tags
+    };
+    return persistedRun;
+  }
+  async postRun(excludeChildRuns = true) {
+    const runtimeEnv = await getRuntimeEnvironment();
+    const runCreate = await this._convertToCreate(this, runtimeEnv, true);
+    await this.client.createRun(runCreate);
+    if (!excludeChildRuns) {
+      warnOnce("Posting with excludeChildRuns=false is deprecated and will be removed in a future version.");
+      for (const childRun of this.child_runs) {
+        await childRun.postRun(false);
+      }
+    }
+  }
+  async patchRun() {
+    var _a;
+    const runUpdate = {
+      end_time: this.end_time,
+      error: this.error,
+      inputs: this.inputs,
+      outputs: this.outputs,
+      parent_run_id: (_a = this.parent_run) == null ? void 0 : _a.id,
+      reference_example_id: this.reference_example_id,
+      extra: this.extra,
+      events: this.events,
+      dotted_order: this.dotted_order,
+      trace_id: this.trace_id,
+      tags: this.tags
+    };
+    await this.client.updateRun(this.id, runUpdate);
+  }
+  toJSON() {
+    return this._convertToCreate(this, void 0, false);
+  }
+  static fromRunnableConfig(parentConfig, props) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const callbackManager = parentConfig == null ? void 0 : parentConfig.callbacks;
+    let parentRun;
+    let projectName;
+    let client;
+    let tracingEnabled = isTracingEnabled();
+    if (callbackManager) {
+      const parentRunId = (_b = (_a = callbackManager == null ? void 0 : callbackManager.getParentRunId) == null ? void 0 : _a.call(callbackManager)) != null ? _b : "";
+      const langChainTracer = (_c = callbackManager == null ? void 0 : callbackManager.handlers) == null ? void 0 : _c.find((handler) => (handler == null ? void 0 : handler.name) == "langchain_tracer");
+      parentRun = (_d = langChainTracer == null ? void 0 : langChainTracer.getRun) == null ? void 0 : _d.call(langChainTracer, parentRunId);
+      projectName = langChainTracer == null ? void 0 : langChainTracer.projectName;
+      client = langChainTracer == null ? void 0 : langChainTracer.client;
+      tracingEnabled = tracingEnabled || !!langChainTracer;
+    }
+    if (!parentRun) {
+      return new _RunTree(__spreadProps(__spreadValues({}, props), {
+        client,
+        tracingEnabled,
+        project_name: projectName
+      }));
+    }
+    const parentRunTree = new _RunTree({
+      name: parentRun.name,
+      id: parentRun.id,
+      client,
+      tracingEnabled,
+      project_name: projectName,
+      tags: [
+        ...new Set(((_e = parentRun == null ? void 0 : parentRun.tags) != null ? _e : []).concat((_f = parentConfig == null ? void 0 : parentConfig.tags) != null ? _f : []))
+      ],
+      extra: {
+        metadata: __spreadValues(__spreadValues({}, (_g = parentRun == null ? void 0 : parentRun.extra) == null ? void 0 : _g.metadata), parentConfig == null ? void 0 : parentConfig.metadata)
+      }
+    });
+    return parentRunTree.createChild(props);
+  }
+  static fromDottedOrder(dottedOrder) {
+    return this.fromHeaders({ "langsmith-trace": dottedOrder });
+  }
+  static fromHeaders(headers, inheritArgs) {
+    var _a, _b, _c, _d;
+    const rawHeaders = "get" in headers && typeof headers.get === "function" ? {
+      "langsmith-trace": headers.get("langsmith-trace"),
+      baggage: headers.get("baggage")
+    } : headers;
+    const headerTrace = rawHeaders["langsmith-trace"];
+    if (!headerTrace || typeof headerTrace !== "string")
+      return void 0;
+    const parentDottedOrder = headerTrace.trim();
+    const parsedDottedOrder = parentDottedOrder.split(".").map((part) => {
+      const [strTime, uuid] = part.split("Z");
+      return { strTime, time: Date.parse(strTime + "Z"), uuid };
+    });
+    const traceId = parsedDottedOrder[0].uuid;
+    const config = __spreadProps(__spreadValues({}, inheritArgs), {
+      name: (_a = inheritArgs == null ? void 0 : inheritArgs["name"]) != null ? _a : "parent",
+      run_type: (_b = inheritArgs == null ? void 0 : inheritArgs["run_type"]) != null ? _b : "chain",
+      start_time: (_c = inheritArgs == null ? void 0 : inheritArgs["start_time"]) != null ? _c : Date.now(),
+      id: (_d = parsedDottedOrder.at(-1)) == null ? void 0 : _d.uuid,
+      trace_id: traceId,
+      dotted_order: parentDottedOrder
+    });
+    if (rawHeaders["baggage"] && typeof rawHeaders["baggage"] === "string") {
+      const baggage = Baggage.fromHeader(rawHeaders["baggage"]);
+      config.metadata = baggage.metadata;
+      config.tags = baggage.tags;
+    }
+    return new _RunTree(config);
+  }
+  toHeaders(headers) {
+    var _a;
+    const result = {
+      "langsmith-trace": this.dotted_order,
+      baggage: new Baggage((_a = this.extra) == null ? void 0 : _a.metadata, this.tags).toHeader()
+    };
+    if (headers) {
+      for (const [key, value] of Object.entries(result)) {
+        headers.set(key, value);
+      }
+    }
+    return result;
+  }
+};
+function isRunTree(x) {
+  return x !== void 0 && typeof x.createChild === "function" && typeof x.postRun === "function";
+}
+function containsLangChainTracerLike(x) {
+  return Array.isArray(x) && x.some((callback) => {
+    return typeof callback.name === "string" && callback.name === "langchain_tracer";
+  });
+}
+function isRunnableConfigLike(x) {
+  var _a;
+  return x !== void 0 && typeof x.callbacks === "object" && // Callback manager with a langchain tracer
+  (containsLangChainTracerLike((_a = x.callbacks) == null ? void 0 : _a.handlers) || // Or it's an array with a LangChainTracerLike object within it
+  containsLangChainTracerLike(x.callbacks));
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/singletons/traceable.js
+var MockAsyncLocalStorage = class {
+  getStore() {
+    return void 0;
+  }
+  run(_, callback) {
+    return callback();
+  }
+};
+var AsyncLocalStorageProvider = class {
+  constructor() {
+    Object.defineProperty(this, "asyncLocalStorage", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: new MockAsyncLocalStorage()
+    });
+    Object.defineProperty(this, "hasBeenInitialized", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
+  }
+  getInstance() {
+    return this.asyncLocalStorage;
+  }
+  initializeGlobalInstance(instance) {
+    if (!this.hasBeenInitialized) {
+      this.hasBeenInitialized = true;
+      this.asyncLocalStorage = instance;
+    }
+  }
+};
+var AsyncLocalStorageProviderSingleton = new AsyncLocalStorageProvider();
+var ROOT = Symbol.for("langsmith:traceable:root");
+function isTraceableFunction(x) {
+  return typeof x === "function" && "langsmith:traceable" in x;
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/utils/asserts.js
+function isPromiseMethod(x) {
+  if (x === "then" || x === "catch" || x === "finally") {
+    return true;
+  }
+  return false;
+}
+function isKVMap(x) {
+  if (typeof x !== "object" || x == null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(x);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in x) && !(Symbol.iterator in x);
+}
+var isAsyncIterable = (x) => x != null && typeof x === "object" && // eslint-disable-next-line @typescript-eslint/no-explicit-any
+typeof x[Symbol.asyncIterator] === "function";
+var isIteratorLike = (x) => x != null && typeof x === "object" && "next" in x && typeof x.next === "function";
+var GeneratorFunction = function* () {
+}.constructor;
+var isGenerator = (x) => (
+  // eslint-disable-next-line no-instanceof/no-instanceof
+  x != null && typeof x === "function" && x instanceof GeneratorFunction
+);
+var isThenable = (x) => x != null && typeof x === "object" && "then" in x && typeof x.then === "function";
+var isReadableStream = (x) => x != null && typeof x === "object" && "getReader" in x && typeof x.getReader === "function";
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/traceable.js
+AsyncLocalStorageProviderSingleton.initializeGlobalInstance(new import_node_async_hooks.AsyncLocalStorage());
+var handleRunInputs = (rawInputs) => {
+  const firstInput = rawInputs[0];
+  if (firstInput == null) {
+    return {};
+  }
+  if (rawInputs.length > 1) {
+    return { args: rawInputs };
+  }
+  if (isKVMap(firstInput)) {
+    return firstInput;
+  }
+  return { input: firstInput };
+};
+var handleRunOutputs = (rawOutputs) => {
+  if (isKVMap(rawOutputs)) {
+    return rawOutputs;
+  }
+  return { outputs: rawOutputs };
+};
+var getTracingRunTree = (runTree, inputs, getInvocationParams) => {
+  var _a;
+  if (!isTracingEnabled(runTree.tracingEnabled)) {
+    return void 0;
+  }
+  runTree.inputs = handleRunInputs(inputs);
+  const invocationParams = getInvocationParams == null ? void 0 : getInvocationParams(...inputs);
+  if (invocationParams != null) {
+    (_a = runTree.extra) != null ? _a : runTree.extra = {};
+    runTree.extra.metadata = __spreadValues(__spreadValues({}, invocationParams), runTree.extra.metadata);
+  }
+  return runTree;
+};
+var getSerializablePromise = (arg) => {
+  const proxyState = { current: void 0 };
+  const promiseProxy = new Proxy(arg, {
+    get(target, prop, receiver) {
+      if (prop === "then") {
+        const boundThen = arg[prop].bind(arg);
+        return (resolve, reject = (x) => {
+          throw x;
+        }) => {
+          return boundThen((value) => {
+            proxyState.current = ["resolve", value];
+            return resolve(value);
+          }, (error) => {
+            proxyState.current = ["reject", error];
+            return reject(error);
+          });
+        };
+      }
+      if (prop === "catch") {
+        const boundCatch = arg[prop].bind(arg);
+        return (reject) => {
+          return boundCatch((error) => {
+            proxyState.current = ["reject", error];
+            return reject(error);
+          });
+        };
+      }
+      if (prop === "toJSON") {
+        return () => {
+          var _a;
+          if (!proxyState.current)
+            return void 0;
+          const [type, value] = (_a = proxyState.current) != null ? _a : [];
+          if (type === "resolve")
+            return value;
+          return { error: value };
+        };
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  return promiseProxy;
+};
+var convertSerializableArg = (arg) => {
+  if (isReadableStream(arg)) {
+    const proxyState = [];
+    const transform = new TransformStream({
+      start: () => void 0,
+      transform: (chunk, controller) => {
+        proxyState.push(chunk);
+        controller.enqueue(chunk);
+      },
+      flush: () => void 0
+    });
+    const pipeThrough = arg.pipeThrough(transform);
+    Object.assign(pipeThrough, { toJSON: () => proxyState });
+    return pipeThrough;
+  }
+  if (isAsyncIterable(arg)) {
+    const proxyState = { current: [] };
+    return new Proxy(arg, {
+      get(target, prop, receiver) {
+        if (prop === Symbol.asyncIterator) {
+          return () => {
+            const boundIterator = arg[Symbol.asyncIterator].bind(arg);
+            const iterator = boundIterator();
+            return new Proxy(iterator, {
+              get(target2, prop2, receiver2) {
+                if (prop2 === "next" || prop2 === "return" || prop2 === "throw") {
+                  const bound = iterator.next.bind(iterator);
+                  return (...args) => {
+                    const wrapped = getSerializablePromise(bound(...args));
+                    proxyState.current.push(wrapped);
+                    return wrapped;
+                  };
+                }
+                if (prop2 === "return" || prop2 === "throw") {
+                  return iterator.next.bind(iterator);
+                }
+                return Reflect.get(target2, prop2, receiver2);
+              }
+            });
+          };
+        }
+        if (prop === "toJSON") {
+          return () => {
+            const onlyNexts = proxyState.current;
+            const serialized = onlyNexts.map((next) => next.toJSON());
+            const chunks = serialized.reduce((memo, next) => {
+              if (next == null ? void 0 : next.value)
+                memo.push(next.value);
+              return memo;
+            }, []);
+            return chunks;
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  if (!Array.isArray(arg) && isIteratorLike(arg)) {
+    const proxyState = [];
+    return new Proxy(arg, {
+      get(target, prop, receiver) {
+        var _a;
+        if (prop === "next" || prop === "return" || prop === "throw") {
+          const bound = (_a = arg[prop]) == null ? void 0 : _a.bind(arg);
+          return (...args) => {
+            const next = bound == null ? void 0 : bound(...args);
+            if (next != null)
+              proxyState.push(next);
+            return next;
+          };
+        }
+        if (prop === "toJSON") {
+          return () => {
+            const chunks = proxyState.reduce((memo, next) => {
+              if (next.value)
+                memo.push(next.value);
+              return memo;
+            }, []);
+            return chunks;
+          };
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  if (isThenable(arg)) {
+    return getSerializablePromise(arg);
+  }
+  return arg;
+};
+function traceable(wrappedFunc, config) {
+  const _a = config != null ? config : {}, { aggregator, argsConfigPath } = _a, runTreeConfig = __objRest(_a, ["aggregator", "argsConfigPath"]);
+  const traceableFunc = (...args) => {
+    var _b, _c, _d;
+    let ensuredConfig;
+    try {
+      let runtimeConfig;
+      if (argsConfigPath) {
+        const [index, path] = argsConfigPath;
+        if (index === args.length - 1 && !path) {
+          runtimeConfig = args.pop();
+        } else if (index <= args.length && typeof args[index] === "object" && args[index] !== null) {
+          if (path) {
+            const _a2 = args[index], { [path]: extracted } = _a2, rest = __objRest(_a2, [__restKey(path)]);
+            runtimeConfig = extracted;
+            args[index] = rest;
+          } else {
+            runtimeConfig = args[index];
+            args.splice(index, 1);
+          }
+        }
+      }
+      ensuredConfig = __spreadProps(__spreadValues(__spreadValues({
+        name: wrappedFunc.name || "<lambda>"
+      }, runTreeConfig), runtimeConfig), {
+        tags: [
+          .../* @__PURE__ */ new Set([
+            ...(_b = runTreeConfig == null ? void 0 : runTreeConfig.tags) != null ? _b : [],
+            ...(_c = runtimeConfig == null ? void 0 : runtimeConfig.tags) != null ? _c : []
+          ])
+        ],
+        metadata: __spreadValues(__spreadValues({}, runTreeConfig == null ? void 0 : runTreeConfig.metadata), runtimeConfig == null ? void 0 : runtimeConfig.metadata)
+      });
+    } catch (err) {
+      console.warn(`Failed to extract runtime config from args for ${(_d = runTreeConfig == null ? void 0 : runTreeConfig.name) != null ? _d : wrappedFunc.name}`, err);
+      ensuredConfig = __spreadValues({
+        name: wrappedFunc.name || "<lambda>"
+      }, runTreeConfig);
+    }
+    const asyncLocalStorage = AsyncLocalStorageProviderSingleton.getInstance();
+    const processedArgs = args;
+    for (let i = 0; i < processedArgs.length; i++) {
+      processedArgs[i] = convertSerializableArg(processedArgs[i]);
+    }
+    const [currentRunTree, rawInputs] = (() => {
+      const [firstArg, ...restArgs] = processedArgs;
+      if (isRunnableConfigLike(firstArg)) {
+        return [
+          getTracingRunTree(RunTree.fromRunnableConfig(firstArg, ensuredConfig), restArgs, config == null ? void 0 : config.getInvocationParams),
+          restArgs
+        ];
+      }
+      if (isRunTree(firstArg) && "callbackManager" in firstArg && firstArg.callbackManager != null) {
+        return [firstArg, restArgs];
+      }
+      if (firstArg === ROOT || isRunTree(firstArg)) {
+        const currentRunTree3 = getTracingRunTree(firstArg === ROOT ? new RunTree(ensuredConfig) : firstArg.createChild(ensuredConfig), restArgs, config == null ? void 0 : config.getInvocationParams);
+        return [currentRunTree3, [currentRunTree3, ...restArgs]];
+      }
+      const prevRunFromStore = asyncLocalStorage.getStore();
+      if (prevRunFromStore) {
+        return [
+          getTracingRunTree(prevRunFromStore.createChild(ensuredConfig), processedArgs, config == null ? void 0 : config.getInvocationParams),
+          processedArgs
+        ];
+      }
+      const currentRunTree2 = getTracingRunTree(new RunTree(ensuredConfig), processedArgs, config == null ? void 0 : config.getInvocationParams);
+      return [currentRunTree2, processedArgs];
+    })();
+    return asyncLocalStorage.run(currentRunTree, () => {
+      const postRunPromise = currentRunTree == null ? void 0 : currentRunTree.postRun();
+      async function handleChunks(chunks) {
+        if (aggregator !== void 0) {
+          try {
+            return await aggregator(chunks);
+          } catch (e) {
+            console.error(`[ERROR]: LangSmith aggregation failed: `, e);
+          }
+        }
+        return chunks;
+      }
+      function wrapAsyncGeneratorForTracing(iterable, snapshot) {
+        return __asyncGenerator(this, null, function* () {
+          let finished = false;
+          const chunks = [];
+          try {
+            const iterator = iterable[Symbol.asyncIterator]();
+            while (true) {
+              const { value, done } = yield new __await(snapshot ? snapshot(() => iterator.next()) : iterator.next());
+              if (done) {
+                finished = true;
+                break;
+              }
+              chunks.push(value);
+              yield value;
+            }
+          } catch (e) {
+            yield new __await(currentRunTree == null ? void 0 : currentRunTree.end(void 0, String(e)));
+            throw e;
+          } finally {
+            if (!finished)
+              yield new __await(currentRunTree == null ? void 0 : currentRunTree.end(void 0, "Cancelled"));
+            yield new __await(currentRunTree == null ? void 0 : currentRunTree.end(handleRunOutputs(yield new __await(handleChunks(chunks)))));
+            yield new __await(handleEnd());
+          }
+        });
+      }
+      async function handleEnd() {
+        const onEnd = config == null ? void 0 : config.on_end;
+        if (onEnd) {
+          if (!currentRunTree) {
+            console.warn("Can not call 'on_end' if currentRunTree is undefined");
+          } else {
+            onEnd(currentRunTree);
+          }
+        }
+        await postRunPromise;
+        await (currentRunTree == null ? void 0 : currentRunTree.patchRun());
+      }
+      function gatherAll(iterator) {
+        const chunks = [];
+        while (true) {
+          const next = iterator.next();
+          chunks.push(next);
+          if (next.done)
+            break;
+        }
+        return chunks;
+      }
+      let returnValue;
+      try {
+        returnValue = wrappedFunc(...rawInputs);
+      } catch (err) {
+        returnValue = Promise.reject(err);
+      }
+      if (isAsyncIterable(returnValue)) {
+        const snapshot = import_node_async_hooks.AsyncLocalStorage.snapshot();
+        return wrapAsyncGeneratorForTracing(returnValue, snapshot);
+      }
+      const tracedPromise = new Promise((resolve, reject) => {
+        Promise.resolve(returnValue).then(async (rawOutput) => {
+          if (isAsyncIterable(rawOutput)) {
+            const snapshot = import_node_async_hooks.AsyncLocalStorage.snapshot();
+            return resolve(wrapAsyncGeneratorForTracing(rawOutput, snapshot));
+          }
+          if (isGenerator(wrappedFunc) && isIteratorLike(rawOutput)) {
+            const chunks = gatherAll(rawOutput);
+            await (currentRunTree == null ? void 0 : currentRunTree.end(handleRunOutputs(await handleChunks(chunks.reduce((memo, { value, done }) => {
+              if (!done || typeof value !== "undefined") {
+                memo.push(value);
+              }
+              return memo;
+            }, [])))));
+            await handleEnd();
+            return function* () {
+              for (const ret of chunks) {
+                if (ret.done)
+                  return ret.value;
+                yield ret.value;
+              }
+            }();
+          }
+          try {
+            await (currentRunTree == null ? void 0 : currentRunTree.end(handleRunOutputs(rawOutput)));
+            await handleEnd();
+          } finally {
+            return rawOutput;
+          }
+        }, async (error) => {
+          await (currentRunTree == null ? void 0 : currentRunTree.end(void 0, String(error)));
+          await handleEnd();
+          throw error;
+        }).then(resolve, reject);
+      });
+      if (typeof returnValue !== "object" || returnValue === null) {
+        return tracedPromise;
+      }
+      return new Proxy(returnValue, {
+        get(target, prop, receiver) {
+          if (isPromiseMethod(prop)) {
+            return tracedPromise[prop].bind(tracedPromise);
+          }
+          return Reflect.get(target, prop, receiver);
+        }
+      });
+    });
+  };
+  Object.defineProperty(traceableFunc, "langsmith:traceable", {
+    value: runTreeConfig
+  });
+  return traceableFunc;
+}
+
+// ../../node_modules/.pnpm/langsmith@0.1.36_openai@4.47.1/node_modules/langsmith/dist/wrappers/openai.js
+function _combineChatCompletionChoices(choices) {
+  var _a, _b;
+  const reversedChoices = choices.slice().reverse();
+  const message = {
+    role: "assistant",
+    content: ""
+  };
+  for (const c of reversedChoices) {
+    if (c.delta.role) {
+      message["role"] = c.delta.role;
+      break;
+    }
+  }
+  const toolCalls = {};
+  for (const c of choices) {
+    if (c.delta.content) {
+      message.content = message.content.concat(c.delta.content);
+    }
+    if (c.delta.function_call) {
+      if (!message.function_call) {
+        message.function_call = { name: "", arguments: "" };
+      }
+      if (c.delta.function_call.name) {
+        message.function_call.name += c.delta.function_call.name;
+      }
+      if (c.delta.function_call.arguments) {
+        message.function_call.arguments += c.delta.function_call.arguments;
+      }
+    }
+    if (c.delta.tool_calls) {
+      for (const tool_call of c.delta.tool_calls) {
+        if (!toolCalls[c.index]) {
+          toolCalls[c.index] = [];
+        }
+        toolCalls[c.index].push(tool_call);
+      }
+    }
+  }
+  if (Object.keys(toolCalls).length > 0) {
+    message.tool_calls = [...Array(Object.keys(toolCalls).length)];
+    for (const [index, toolCallChunks] of Object.entries(toolCalls)) {
+      const idx = parseInt(index);
+      message.tool_calls[idx] = {
+        index: idx,
+        id: ((_a = toolCallChunks.find((c) => c.id)) == null ? void 0 : _a.id) || null,
+        type: ((_b = toolCallChunks.find((c) => c.type)) == null ? void 0 : _b.type) || null
+      };
+      for (const chunk of toolCallChunks) {
+        if (chunk.function) {
+          if (!message.tool_calls[idx].function) {
+            message.tool_calls[idx].function = {
+              name: "",
+              arguments: ""
+            };
+          }
+          if (chunk.function.name) {
+            message.tool_calls[idx].function.name += chunk.function.name;
+          }
+          if (chunk.function.arguments) {
+            message.tool_calls[idx].function.arguments += chunk.function.arguments;
+          }
+        }
+      }
+    }
+  }
+  return {
+    index: choices[0].index,
+    finish_reason: reversedChoices.find((c) => c.finish_reason) || null,
+    message
+  };
+}
+var chatAggregator = (chunks) => {
+  if (!chunks || chunks.length === 0) {
+    return { choices: [{ message: { role: "assistant", content: "" } }] };
+  }
+  const choicesByIndex = {};
+  for (const chunk of chunks) {
+    for (const choice of chunk.choices) {
+      if (choicesByIndex[choice.index] === void 0) {
+        choicesByIndex[choice.index] = [];
+      }
+      choicesByIndex[choice.index].push(choice);
+    }
+  }
+  const aggregatedOutput = chunks[chunks.length - 1];
+  aggregatedOutput.choices = Object.values(choicesByIndex).map((choices) => _combineChatCompletionChoices(choices));
+  return aggregatedOutput;
+};
+var textAggregator = (allChunks) => {
+  if (allChunks.length === 0) {
+    return { choices: [{ text: "" }] };
+  }
+  const allContent = [];
+  for (const chunk of allChunks) {
+    const content2 = chunk.choices[0].text;
+    if (content2 != null) {
+      allContent.push(content2);
+    }
+  }
+  const content = allContent.join("");
+  const aggregatedOutput = allChunks[allChunks.length - 1];
+  aggregatedOutput.choices = [
+    __spreadProps(__spreadValues({}, aggregatedOutput.choices[0]), { text: content })
+  ];
+  return aggregatedOutput;
+};
+var wrapOpenAI = (openai, options) => {
+  if (isTraceableFunction(openai.chat.completions.create) || isTraceableFunction(openai.completions.create)) {
+    throw new Error("This instance of OpenAI client has been already wrapped once.");
+  }
+  openai.chat.completions.create = traceable(openai.chat.completions.create.bind(openai.chat.completions), __spreadValues({
+    name: "ChatOpenAI",
+    run_type: "llm",
+    aggregator: chatAggregator,
+    argsConfigPath: [1, "langsmithExtra"],
+    getInvocationParams: (payload) => {
+      var _a, _b, _c;
+      if (typeof payload !== "object" || payload == null)
+        return void 0;
+      const params = payload;
+      const ls_stop = (_a = typeof params.stop === "string" ? [params.stop] : params.stop) != null ? _a : void 0;
+      return {
+        ls_provider: "openai",
+        ls_model_type: "chat",
+        ls_model_name: params.model,
+        ls_max_tokens: (_b = params.max_tokens) != null ? _b : void 0,
+        ls_temperature: (_c = params.temperature) != null ? _c : void 0,
+        ls_stop
+      };
+    }
+  }, options));
+  openai.completions.create = traceable(openai.completions.create.bind(openai.completions), __spreadValues({
+    name: "OpenAI",
+    run_type: "llm",
+    aggregator: textAggregator,
+    argsConfigPath: [1, "langsmithExtra"],
+    getInvocationParams: (payload) => {
+      var _a, _b, _c;
+      if (typeof payload !== "object" || payload == null)
+        return void 0;
+      const params = payload;
+      const ls_stop = (_a = typeof params.stop === "string" ? [params.stop] : params.stop) != null ? _a : void 0;
+      return {
+        ls_provider: "openai",
+        ls_model_type: "text",
+        ls_model_name: params.model,
+        ls_max_tokens: (_b = params.max_tokens) != null ? _b : void 0,
+        ls_temperature: (_c = params.temperature) != null ? _c : void 0,
+        ls_stop
+      };
+    }
+  }, options));
+  return openai;
+};
 
 // src/ai-model/openai.ts
-var import_assert = __toESM(require("assert"));
-var import_openai = __toESM(require("openai"));
-var import_wrappers = __toESM(require("langsmith/wrappers"));
 var envConfigKey = "MIDSCENE_OPENAI_INIT_CONFIG_JSON";
 var envModelKey = "MIDSCENE_MODEL_NAME";
 var envSmithDebug = "MIDSCENE_LANGSMITH_DEBUG";
 var extraConfig = {};
 if (typeof process.env[envConfigKey] === "string") {
-  console.log("will use env config for openai");
+  console.log("config for openai loaded");
   extraConfig = JSON.parse(process.env[envConfigKey]);
 }
 var model = "gpt-4o";
 if (typeof process.env[envModelKey] === "string") {
-  console.log(`will use model: ${process.env[envModelKey]}`);
+  console.log(`model: ${process.env[envModelKey]}`);
   model = process.env[envModelKey];
 }
 async function createOpenAI() {
   const openai = new import_openai.default(extraConfig);
   if (process.env[envSmithDebug]) {
-    console.log("DEBUGGING MODE: using langsmith wrapper");
-    const openai2 = import_wrappers.default.wrapOpenAI(new import_openai.default());
+    console.log("DEBUGGING MODE: langsmith wrapper enabled");
+    const openai2 = wrapOpenAI(new import_openai.default());
     return openai2;
   }
   return openai;
@@ -231,7 +4413,7 @@ var import_assert3 = __toESM(require("assert"));
 
 // src/image/info.ts
 var import_node_assert = __toESM(require("assert"));
-var import_buffer = require("buffer");
+var import_node_buffer = require("buffer");
 var import_node_fs = require("fs");
 var import_sharp = __toESM(require("sharp"));
 async function imageInfo(image) {
@@ -241,22 +4423,22 @@ async function imageInfo(image) {
 }
 async function imageInfoOfBase64(imageBase64) {
   const base64Data = imageBase64.replace(/^data:image\/\w+;base64,/, "");
-  return imageInfo(import_buffer.Buffer.from(base64Data, "base64"));
+  return imageInfo(import_node_buffer.Buffer.from(base64Data, "base64"));
 }
 
 // src/image/transform.ts
-var import_node_buffer = require("buffer");
+var import_node_buffer2 = require("buffer");
 var import_sharp2 = __toESM(require("sharp"));
 
 // src/image/visualization.ts
-var import_buffer2 = require("buffer");
+var import_buffer = require("buffer");
 var import_sharp3 = __toESM(require("sharp"));
 
 // src/utils.ts
 var import_os = require("os");
 var import_path = require("path");
 var import_fs = require("fs");
-var import_crypto = require("crypto");
+var import_crypto3 = require("crypto");
 var import_assert2 = __toESM(require("assert"));
 var logDir = (0, import_path.join)(process.cwd(), "./midscene_run/");