@midscene/mcp 0.30.8 → 0.30.9

package/dist/{290.js → 217.js}

@@ -1,14 +1,728 @@
-"use strict";
 exports.ids = [
-    "290"
+    "217"
 ];
 exports.modules = {
+    "../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js": function(module) {
+        "use strict";
+        var has = Object.prototype.hasOwnProperty, prefix = '~';
+        function Events() {}
+        if (Object.create) {
+            Events.prototype = 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 ('function' != typeof fn) 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]) if (emitter._events[evt].fn) emitter._events[evt] = [
+                emitter._events[evt],
+                listener
+            ];
+            else emitter._events[evt].push(listener);
+            else emitter._events[evt] = listener, emitter._eventsCount++;
+            return emitter;
+        }
+        function clearEvent(emitter, evt) {
+            if (0 === --emitter._eventsCount) emitter._events = new Events();
+            else delete emitter._events[evt];
+        }
+        function EventEmitter() {
+            this._events = new Events();
+            this._eventsCount = 0;
+        }
+        EventEmitter.prototype.eventNames = function() {
+            var names = [], events, name;
+            if (0 === this._eventsCount) 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(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(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(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(event, fn, context) {
+            return addListener(this, event, fn, context, false);
+        };
+        EventEmitter.prototype.once = function(event, fn, context) {
+            return addListener(this, event, fn, context, true);
+        };
+        EventEmitter.prototype.removeListener = function(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] = 1 === events.length ? events[0] : events;
+                else clearEvent(this, evt);
+            }
+            return this;
+        };
+        EventEmitter.prototype.removeAllListeners = function(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;
+        module.exports = EventEmitter;
+    },
+    "../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js": function(module) {
+        "use strict";
+        module.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-queue@6.6.2/node_modules/p-queue/dist/index.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: true
+        });
+        const EventEmitter = __webpack_require__("../../node_modules/.pnpm/eventemitter3@4.0.7/node_modules/eventemitter3/index.js");
+        const p_timeout_1 = __webpack_require__("../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js");
+        const priority_queue_1 = __webpack_require__("../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js");
+        const empty = ()=>{};
+        const timeoutError = new p_timeout_1.TimeoutError();
+        class PQueue 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: 1 / 0,
+                    interval: 0,
+                    concurrency: 1 / 0,
+                    autoStart: true,
+                    queueClass: priority_queue_1.default
+                }, options);
+                if (!('number' == typeof options.intervalCap && options.intervalCap >= 1)) throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${null != (_b = null == (_a = options.intervalCap) ? void 0 : _a.toString()) ? _b : ''}\` (${typeof options.intervalCap})`);
+                if (void 0 === options.interval || !(Number.isFinite(options.interval) && options.interval >= 0)) throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${null != (_d = null == (_c = options.interval) ? void 0 : _c.toString()) ? _d : ''}\` (${typeof options.interval})`);
+                this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+                this._isIntervalIgnored = options.intervalCap === 1 / 0 || 0 === options.interval;
+                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 = true === options.throwOnTimeout;
+                this._isPaused = false === options.autoStart;
+            }
+            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 (0 === this._pendingCount) {
+                    this._resolveIdle();
+                    this._resolveIdle = empty;
+                    this.emit('idle');
+                }
+            }
+            _onResumeInterval() {
+                this._onInterval();
+                this._initializeIntervalIfNeeded();
+                this._timeoutId = void 0;
+            }
+            _isIntervalPaused() {
+                const now = Date.now();
+                if (void 0 === this._intervalId) {
+                    const delay = this._intervalEnd - now;
+                    if (delay < 0) this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+                    else {
+                        if (void 0 === this._timeoutId) this._timeoutId = setTimeout(()=>{
+                            this._onResumeInterval();
+                        }, delay);
+                        return true;
+                    }
+                }
+                return false;
+            }
+            _tryToStartAnother() {
+                if (0 === this._queue.size) {
+                    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 || void 0 !== this._intervalId) return;
+                this._intervalId = setInterval(()=>{
+                    this._onInterval();
+                }, this._interval);
+                this._intervalEnd = Date.now() + this._interval;
+            }
+            _onInterval() {
+                if (0 === this._intervalCount && 0 === this._pendingCount && this._intervalId) {
+                    clearInterval(this._intervalId);
+                    this._intervalId = void 0;
+                }
+                this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
+                this._processQueue();
+            }
+            _processQueue() {
+                while(this._tryToStartAnother());
+            }
+            get concurrency() {
+                return this._concurrency;
+            }
+            set concurrency(newConcurrency) {
+                if (!('number' == typeof newConcurrency && newConcurrency >= 1)) throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+                this._concurrency = newConcurrency;
+                this._processQueue();
+            }
+            async add(fn, options = {}) {
+                return new Promise((resolve, reject)=>{
+                    const run = async ()=>{
+                        this._pendingCount++;
+                        this._intervalCount++;
+                        try {
+                            const operation = void 0 === this._timeout && void 0 === options.timeout ? fn() : p_timeout_1.default(Promise.resolve(fn()), void 0 === options.timeout ? this._timeout : options.timeout, ()=>{
+                                if (void 0 === options.throwOnTimeout ? this._throwOnTimeout : options.throwOnTimeout) reject(timeoutError);
+                            });
+                            resolve(await operation);
+                        } catch (error) {
+                            reject(error);
+                        }
+                        this._next();
+                    };
+                    this._queue.enqueue(run, options);
+                    this._tryToStartAnother();
+                    this.emit('add');
+                });
+            }
+            async addAll(functions, options) {
+                return Promise.all(functions.map(async (function_)=>this.add(function_, options)));
+            }
+            start() {
+                if (!this._isPaused) return this;
+                this._isPaused = false;
+                this._processQueue();
+                return this;
+            }
+            pause() {
+                this._isPaused = true;
+            }
+            clear() {
+                this._queue = new this._queueClass();
+            }
+            async onEmpty() {
+                if (0 === this._queue.size) return;
+                return new Promise((resolve)=>{
+                    const existingResolve = this._resolveEmpty;
+                    this._resolveEmpty = ()=>{
+                        existingResolve();
+                        resolve();
+                    };
+                });
+            }
+            async onIdle() {
+                if (0 === this._pendingCount && 0 === this._queue.size) return;
+                return new Promise((resolve)=>{
+                    const existingResolve = this._resolveIdle;
+                    this._resolveIdle = ()=>{
+                        existingResolve();
+                        resolve();
+                    };
+                });
+            }
+            get size() {
+                return this._queue.size;
+            }
+            sizeBy(options) {
+                return this._queue.filter(options).length;
+            }
+            get pending() {
+                return this._pendingCount;
+            }
+            get isPaused() {
+                return this._isPaused;
+            }
+            get timeout() {
+                return this._timeout;
+            }
+            set timeout(milliseconds) {
+                this._timeout = milliseconds;
+            }
+        }
+        exports1["default"] = PQueue;
+    },
+    "../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js": function(__unused_webpack_module, exports1) {
+        "use strict";
+        Object.defineProperty(exports1, "__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;
+        }
+        exports1["default"] = lowerBound;
+    },
+    "../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/priority-queue.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: true
+        });
+        const lower_bound_1 = __webpack_require__("../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/lower-bound.js");
+        class PriorityQueue {
+            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) return void this._queue.push(element);
+                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 null == item ? 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;
+            }
+        }
+        exports1["default"] = PriorityQueue;
+    },
+    "../../node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const retry = __webpack_require__("../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js");
+        const networkErrorMsgs = [
+            'Failed to fetch',
+            'NetworkError when attempting to fetch resource.',
+            'The Internet connection appears to be offline.',
+            'Network request failed'
+        ];
+        class AbortError 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;
+            }
+        }
+        const decorateErrorWithCounts = (error, attemptNumber, options)=>{
+            const retriesLeft = options.retries - (attemptNumber - 1);
+            error.attemptNumber = attemptNumber;
+            error.retriesLeft = retriesLeft;
+            return error;
+        };
+        const isNetworkError = (errorMessage)=>networkErrorMsgs.includes(errorMessage);
+        const pRetry = (input, options)=>new Promise((resolve, reject)=>{
+                options = {
+                    onFailedAttempt: ()=>{},
+                    retries: 10,
+                    ...options
+                };
+                const operation = retry.operation(options);
+                operation.attempt(async (attemptNumber)=>{
+                    try {
+                        resolve(await input(attemptNumber));
+                    } catch (error) {
+                        if (!(error instanceof Error)) return void reject(new TypeError(`Non-error was thrown: "${error}". You should only throw errors.`));
+                        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 (error) {
+                                reject(error);
+                                return;
+                            }
+                            if (!operation.retry(error)) reject(operation.mainError());
+                        }
+                    }
+                });
+            });
+        module.exports = pRetry;
+        module.exports["default"] = pRetry;
+        module.exports.AbortError = AbortError;
+    },
+    "../../node_modules/.pnpm/p-timeout@3.2.0/node_modules/p-timeout/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const pFinally = __webpack_require__("../../node_modules/.pnpm/p-finally@1.0.0/node_modules/p-finally/index.js");
+        class TimeoutError extends Error {
+            constructor(message){
+                super(message);
+                this.name = 'TimeoutError';
+            }
+        }
+        const pTimeout = (promise, milliseconds, fallback)=>new Promise((resolve, reject)=>{
+                if ('number' != typeof milliseconds || milliseconds < 0) throw new TypeError('Expected `milliseconds` to be a positive number');
+                if (milliseconds === 1 / 0) return void resolve(promise);
+                const timer = setTimeout(()=>{
+                    if ('function' == typeof fallback) {
+                        try {
+                            resolve(fallback());
+                        } catch (error) {
+                            reject(error);
+                        }
+                        return;
+                    }
+                    const message = 'string' == typeof fallback ? fallback : `Promise timed out after ${milliseconds} milliseconds`;
+                    const timeoutError = fallback instanceof Error ? fallback : new TimeoutError(message);
+                    if ('function' == typeof promise.cancel) promise.cancel();
+                    reject(timeoutError);
+                }, milliseconds);
+                pFinally(promise.then(resolve, reject), ()=>{
+                    clearTimeout(timer);
+                });
+            });
+        module.exports = pTimeout;
+        module.exports["default"] = pTimeout;
+        module.exports.TimeoutError = TimeoutError;
+    },
+    "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        module.exports = __webpack_require__("../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js");
+    },
+    "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        var RetryOperation = __webpack_require__("../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js");
+        exports1.operation = function(options) {
+            var timeouts = exports1.timeouts(options);
+            return new RetryOperation(timeouts, {
+                forever: options && (options.forever || options.retries === 1 / 0),
+                unref: options && options.unref,
+                maxRetryTime: options && options.maxRetryTime
+            });
+        };
+        exports1.timeouts = function(options) {
+            if (options instanceof Array) return [].concat(options);
+            var opts = {
+                retries: 10,
+                factor: 2,
+                minTimeout: 1000,
+                maxTimeout: 1 / 0,
+                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;
+        };
+        exports1.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;
+        };
+        exports1.wrap = function(obj, options, methods) {
+            if (options instanceof Array) {
+                methods = options;
+                options = null;
+            }
+            if (!methods) {
+                methods = [];
+                for(var key in obj)if ('function' == typeof obj[key]) methods.push(key);
+            }
+            for(var i = 0; i < methods.length; i++){
+                var method = methods[i];
+                var original = obj[method];
+                obj[method] = (function(original) {
+                    var op = exports1.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() {
+                        original.apply(obj, args);
+                    });
+                }).bind(obj, original);
+                obj[method].options = options;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/retry@0.13.1/node_modules/retry/lib/retry_operation.js": function(module) {
+        function RetryOperation(timeouts, options) {
+            if ('boolean' == typeof options) options = {
+                forever: options
+            };
+            this._originalTimeouts = JSON.parse(JSON.stringify(timeouts));
+            this._timeouts = timeouts;
+            this._options = options || {};
+            this._maxRetryTime = options && options.maxRetryTime || 1 / 0;
+            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);
+        }
+        module.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 = 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 (void 0 === timeout) if (!this._cachedTimeouts) return false;
+            else {
+                this._errors.splice(0, this._errors.length - 1);
+                timeout = this._cachedTimeouts.slice(-1);
+            }
+            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 = 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 (0 === this._errors.length) 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/langsmith@0.3.7_openai@4.81.0_ws@8.18.3_zod@3.24.3_/node_modules/langsmith/wrappers.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        "use strict";
         __webpack_require__.d(__webpack_exports__, {
             wrapOpenAI: ()=>wrapOpenAI
         });
         var external_node_async_hooks_ = __webpack_require__("node:async_hooks");
-        var v4 = __webpack_require__("../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v4.js");
+        var external_node_crypto_ = __webpack_require__("node:crypto");
+        var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_);
+        const esm_node_native = {
+            randomUUID: external_node_crypto_default().randomUUID
+        };
+        const rnds8Pool = new Uint8Array(256);
+        let poolPtr = rnds8Pool.length;
+        function rng() {
+            if (poolPtr > rnds8Pool.length - 16) {
+                external_node_crypto_default().randomFillSync(rnds8Pool);
+                poolPtr = 0;
+            }
+            return rnds8Pool.slice(poolPtr, poolPtr += 16);
+        }
+        const byteToHex = [];
+        for(let i = 0; i < 256; ++i)byteToHex.push((i + 0x100).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]]).toLowerCase();
+        }
+        function v4_v4(options, buf, offset) {
+            if (esm_node_native.randomUUID && !buf && !options) return esm_node_native.randomUUID();
+            options = options || {};
+            const rnds = options.random || (options.rng || rng)();
+            rnds[6] = 0x0f & rnds[6] | 0x40;
+            rnds[8] = 0x3f & rnds[8] | 0x80;
+            if (buf) {
+                offset = offset || 0;
+                for(let i = 0; i < 16; ++i)buf[offset + i] = rnds[i];
+                return buf;
+            }
+            return unsafeStringify(rnds);
+        }
+        const v4 = v4_v4;
         var p_retry = __webpack_require__("../../node_modules/.pnpm/p-retry@4.6.2/node_modules/p-retry/index.js");
         var dist = __webpack_require__("../../node_modules/.pnpm/p-queue@6.6.2/node_modules/p-queue/dist/index.js");
         const DEFAULT_FETCH_IMPLEMENTATION = (...args)=>fetch(...args);
@@ -116,9 +830,13 @@ exports.modules = {
             };
             return converted;
         }
-        var validate = __webpack_require__("../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/validate.js");
+        const regex = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+        function validate_validate(uuid) {
+            return 'string' == typeof uuid && regex.test(uuid);
+        }
+        const esm_node_validate = validate_validate;
         function assertUuid(str, which) {
-            if (!validate.Z(str)) {
+            if (!esm_node_validate(str)) {
                 const msg = void 0 !== which ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
                 throw new Error(msg);
             }
@@ -173,7 +891,7 @@ exports.modules = {
         var CIRCULAR_REPLACE_NODE = {
             result: "[Circular]"
         };
-        var arr = [];
+        var fast_safe_stringify_arr = [];
         var replacerStack = [];
         const encoder = new TextEncoder();
         function defaultOptions() {
@@ -203,8 +921,8 @@ exports.modules = {
                 } catch (_) {
                     return encodeString("[unable to serialize, circular reference is too complex to analyze]");
                 } finally{
-                    while(0 !== arr.length){
-                        const part = arr.pop();
+                    while(0 !== fast_safe_stringify_arr.length){
+                        const part = fast_safe_stringify_arr.pop();
                         if (4 === part.length) Object.defineProperty(part[0], part[1], part[3]);
                         else part[0][part[1]] = part[2];
                     }
@@ -218,7 +936,7 @@ exports.modules = {
                 Object.defineProperty(parent, k, {
                     value: replace
                 });
-                arr.push([
+                fast_safe_stringify_arr.push([
                     parent,
                     k,
                     val,
@@ -231,7 +949,7 @@ exports.modules = {
             ]);
             else {
                 parent[k] = replace;
-                arr.push([
+                fast_safe_stringify_arr.push([
                     parent,
                     k,
                     val
@@ -1205,7 +1923,7 @@ exports.modules = {
             async shareRun(runId, { shareId } = {}) {
                 const data = {
                     run_id: runId,
-                    share_token: shareId || v4.Z()
+                    share_token: shareId || v4()
                 };
                 assertUuid(runId);
                 const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/runs/${runId}/share`, {
@@ -2028,7 +2746,7 @@ exports.modules = {
                 };
                 if (feedback_source?.metadata !== void 0 && feedback_source.metadata["__run"]?.run_id !== void 0) assertUuid(feedback_source.metadata["__run"].run_id);
                 const feedback = {
-                    id: feedbackId ?? v4.Z(),
+                    id: feedbackId ?? v4(),
                     run_id: runId,
                     key,
                     score,
@@ -2219,7 +2937,7 @@ exports.modules = {
                 const body = {
                     name,
                     description,
-                    id: queueId || v4.Z()
+                    id: queueId || v4()
                 };
                 const response = await this.caller.call(_getFetchImplementation(), `${this.apiUrl}/annotation-queues`, {
                     method: "POST",
@@ -2541,7 +3259,7 @@ exports.modules = {
                 if (!await this._getMultiPartSupport()) throw new Error("Your LangSmith version does not allow using the multipart examples endpoint, please update to the latest version.");
                 const formData = new FormData();
                 for (const example of uploads){
-                    const exampleId = (example.id ?? v4.Z()).toString();
+                    const exampleId = (example.id ?? v4()).toString();
                     const exampleBody = {
                         created_at: example.created_at,
                         ...example.metadata && {
@@ -3069,7 +3787,7 @@ exports.modules = {
             }
             static getDefaultConfig() {
                 return {
-                    id: v4.Z(),
+                    id: v4(),
                     run_type: "chain",
                     project_name: getLangSmithEnvironmentVariable("PROJECT") ?? getEnvironmentVariable("LANGCHAIN_SESSION") ?? "default",
                     child_runs: [],