@flatfile/improv
Version:
A powerful TypeScript library for building AI agents with multi-threaded conversations, tool execution, and event handling capabilities
1,427 lines (1,402 loc) • 1.34 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" is not supported');
});
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require2() {
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);
// src/tracing/tracer.ts
var NullTracer, defaultTracer;
var init_tracer = __esm({
"src/tracing/tracer.ts"() {
"use strict";
NullTracer = class {
static {
__name(this, "NullTracer");
}
traceable(fn, _metadata) {
return fn;
}
};
defaultTracer = new NullTracer();
}
});
// src/tracing/registry.ts
var registry_exports = {};
__export(registry_exports, {
TracerRegistry: () => TracerRegistry,
getTracer: () => getTracer,
isTracingEnabled: () => isTracingEnabled
});
function getTracer() {
return TracerRegistry.getInstance().getActiveTracer();
}
function isTracingEnabled() {
return TracerRegistry.getInstance().isTracingEnabled();
}
var TracerRegistry;
var init_registry = __esm({
"src/tracing/registry.ts"() {
"use strict";
init_tracer();
TracerRegistry = class _TracerRegistry {
static {
__name(this, "TracerRegistry");
}
static instance;
tracers = /* @__PURE__ */ new Map();
activeTracer = "null";
constructor() {
this.register("null", defaultTracer);
}
/**
* Get the singleton instance of the registry
*/
static getInstance() {
if (!_TracerRegistry.instance) {
_TracerRegistry.instance = new _TracerRegistry();
}
return _TracerRegistry.instance;
}
/**
* Register a tracer with the registry
* @param name Name of the tracer
* @param tracer The tracer implementation
*/
register(name, tracer) {
this.tracers.set(name, tracer);
}
/**
* Set the active tracer by name
* @param name Name of the tracer to activate
* @throws Error if the tracer doesn't exist
*/
setActiveTracer(name) {
if (!this.tracers.has(name)) {
throw new Error(`Tracer '${name}' is not registered`);
}
this.activeTracer = name;
}
/**
* Get the currently active tracer
*/
getActiveTracer() {
return this.tracers.get(this.activeTracer) || defaultTracer;
}
/**
* Check if tracing is enabled (i.e., active tracer is not the null tracer)
*/
isTracingEnabled() {
return this.activeTracer !== "null";
}
};
__name(getTracer, "getTracer");
__name(isTracingEnabled, "isTracingEnabled");
}
});
// src/tracing/index.ts
var tracing_exports = {};
__export(tracing_exports, {
NullTracer: () => NullTracer,
TracerRegistry: () => TracerRegistry,
defaultTracer: () => defaultTracer,
getTracer: () => getTracer,
isTracingEnabled: () => isTracingEnabled,
traceable: () => traceable
});
function traceable(fn, metadata) {
if (!isTracingEnabled()) {
return fn;
}
return getTracer().traceable(fn, metadata);
}
var init_tracing = __esm({
"src/tracing/index.ts"() {
"use strict";
init_tracer();
init_registry();
__name(traceable, "traceable");
}
});
// node_modules/retry/lib/retry_operation.js
var require_retry_operation = __commonJS({
"node_modules/retry/lib/retry_operation.js"(exports, module) {
"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);
}
}
__name(RetryOperation, "RetryOperation");
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 = (/* @__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 error2 = this._errors[i];
var message = error2.message;
var count = (counts[message] || 0) + 1;
counts[message] = count;
if (count >= mainErrorCount) {
mainError = error2;
mainErrorCount = count;
}
}
return mainError;
};
}
});
// node_modules/retry/lib/retry.js
var require_retry = __commonJS({
"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(attempt2, opts) {
var random = opts.randomize ? Math.random() + 1 : 1;
var timeout = Math.round(random * Math.max(opts.minTimeout, 1) * Math.pow(opts.factor, attempt2));
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] = (/* @__PURE__ */ __name(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);
});
}, "retryWrapper")).bind(obj, original);
obj[method].options = options;
}
};
}
});
// node_modules/retry/index.js
var require_retry2 = __commonJS({
"node_modules/retry/index.js"(exports, module) {
"use strict";
module.exports = require_retry();
}
});
// node_modules/p-retry/index.js
var require_p_retry = __commonJS({
"node_modules/p-retry/index.js"(exports, module) {
"use strict";
var retry = require_retry2();
var networkErrorMsgs = [
"Failed to fetch",
"NetworkError when attempting to fetch resource.",
"The Internet connection appears to be offline.",
"Network request failed"
// `cross-fetch`
];
var AbortError = class AbortError extends Error {
static {
__name(this, "AbortError");
}
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 = /* @__PURE__ */ __name((error2, attemptNumber, options) => {
const retriesLeft = options.retries - (attemptNumber - 1);
error2.attemptNumber = attemptNumber;
error2.retriesLeft = retriesLeft;
return error2;
}, "decorateErrorWithCounts");
var isNetworkError = /* @__PURE__ */ __name((errorMessage) => networkErrorMsgs.includes(errorMessage), "isNetworkError");
var pRetry = /* @__PURE__ */ __name((input, options) => new Promise((resolve, reject2) => {
options = {
onFailedAttempt: /* @__PURE__ */ __name(() => {
}, "onFailedAttempt"),
retries: 10,
...options
};
const operation = retry.operation(options);
operation.attempt(async (attemptNumber) => {
try {
resolve(await input(attemptNumber));
} catch (error2) {
if (!(error2 instanceof Error)) {
reject2(new TypeError(`Non-error was thrown: "${error2}". You should only throw errors.`));
return;
}
if (error2 instanceof AbortError) {
operation.stop();
reject2(error2.originalError);
} else if (error2 instanceof TypeError && !isNetworkError(error2.message)) {
operation.stop();
reject2(error2);
} else {
decorateErrorWithCounts(error2, attemptNumber, options);
try {
await options.onFailedAttempt(error2);
} catch (error3) {
reject2(error3);
return;
}
if (!operation.retry(error2)) {
reject2(operation.mainError());
}
}
}
});
}), "pRetry");
module.exports = pRetry;
module.exports.default = pRetry;
module.exports.AbortError = AbortError;
}
});
// node_modules/eventemitter3/index.js
var require_eventemitter3 = __commonJS({
"node_modules/eventemitter3/index.js"(exports, module) {
"use strict";
var has = Object.prototype.hasOwnProperty;
var prefix = "~";
function Events() {
}
__name(Events, "Events");
if (Object.create) {
Events.prototype = /* @__PURE__ */ Object.create(null);
if (!new Events().__proto__) prefix = false;
}
function EE(fn, context, once2) {
this.fn = fn;
this.context = context;
this.once = once2 || false;
}
__name(EE, "EE");
function addListener(emitter, event, fn, context, once2) {
if (typeof fn !== "function") {
throw new TypeError("The listener must be a function");
}
var listener = new EE(fn, context || emitter, once2), 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;
}
__name(addListener, "addListener");
function clearEvent(emitter, evt) {
if (--emitter._eventsCount === 0) emitter._events = new Events();
else delete emitter._events[evt];
}
__name(clearEvent, "clearEvent");
function EventEmitter3() {
this._events = new Events();
this._eventsCount = 0;
}
__name(EventEmitter3, "EventEmitter");
EventEmitter3.prototype.eventNames = /* @__PURE__ */ __name(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;
}, "eventNames");
EventEmitter3.prototype.listeners = /* @__PURE__ */ __name(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;
}, "listeners");
EventEmitter3.prototype.listenerCount = /* @__PURE__ */ __name(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;
}, "listenerCount");
EventEmitter3.prototype.emit = /* @__PURE__ */ __name(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;
}, "emit");
EventEmitter3.prototype.on = /* @__PURE__ */ __name(function on(event, fn, context) {
return addListener(this, event, fn, context, false);
}, "on");
EventEmitter3.prototype.once = /* @__PURE__ */ __name(function once2(event, fn, context) {
return addListener(this, event, fn, context, true);
}, "once");
EventEmitter3.prototype.removeListener = /* @__PURE__ */ __name(function removeListener(event, fn, context, once2) {
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 && (!once2 || 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 || once2 && !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;
}, "removeListener");
EventEmitter3.prototype.removeAllListeners = /* @__PURE__ */ __name(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;
}, "removeAllListeners");
EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
EventEmitter3.prefixed = prefix;
EventEmitter3.EventEmitter = EventEmitter3;
if ("undefined" !== typeof module) {
module.exports = EventEmitter3;
}
}
});
// node_modules/p-finally/index.js
var require_p_finally = __commonJS({
"node_modules/p-finally/index.js"(exports, 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/p-timeout/index.js
var require_p_timeout = __commonJS({
"node_modules/p-timeout/index.js"(exports, module) {
"use strict";
var pFinally = require_p_finally();
var TimeoutError = class TimeoutError extends Error {
static {
__name(this, "TimeoutError");
}
constructor(message) {
super(message);
this.name = "TimeoutError";
}
};
var pTimeout = /* @__PURE__ */ __name((promise, milliseconds, fallback2) => new Promise((resolve, reject2) => {
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 fallback2 === "function") {
try {
resolve(fallback2());
} catch (error2) {
reject2(error2);
}
return;
}
const message = typeof fallback2 === "string" ? fallback2 : `Promise timed out after ${milliseconds} milliseconds`;
const timeoutError = fallback2 instanceof Error ? fallback2 : new TimeoutError(message);
if (typeof promise.cancel === "function") {
promise.cancel();
}
reject2(timeoutError);
}, milliseconds);
pFinally(
// eslint-disable-next-line promise/prefer-await-to-then
promise.then(resolve, reject2),
() => {
clearTimeout(timer);
}
);
}), "pTimeout");
module.exports = pTimeout;
module.exports.default = pTimeout;
module.exports.TimeoutError = TimeoutError;
}
});
// node_modules/p-queue/dist/lower-bound.js
var require_lower_bound = __commonJS({
"node_modules/p-queue/dist/lower-bound.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
function lowerBound(array, value, comparator) {
let first2 = 0;
let count = array.length;
while (count > 0) {
const step = count / 2 | 0;
let it = first2 + step;
if (comparator(array[it], value) <= 0) {
first2 = ++it;
count -= step + 1;
} else {
count = step;
}
}
return first2;
}
__name(lowerBound, "lowerBound");
exports.default = lowerBound;
}
});
// node_modules/p-queue/dist/priority-queue.js
var require_priority_queue = __commonJS({
"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 PriorityQueue {
static {
__name(this, "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) {
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/p-queue/dist/index.js
var require_dist = __commonJS({
"node_modules/p-queue/dist/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var EventEmitter3 = require_eventemitter3();
var p_timeout_1 = require_p_timeout();
var priority_queue_1 = require_priority_queue();
var empty = /* @__PURE__ */ __name(() => {
}, "empty");
var timeoutError = new p_timeout_1.TimeoutError();
var PQueue = class PQueue extends EventEmitter3 {
static {
__name(this, "PQueue");
}
constructor(options) {
var _a3, _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 = (_a3 = options.intervalCap) === null || _a3 === void 0 ? void 0 : _a3.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 now2 = Date.now();
if (this._intervalId === void 0) {
const delay2 = this._intervalEnd - now2;
if (delay2 < 0) {
this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
} else {
if (this._timeoutId === void 0) {
this._timeoutId = setTimeout(() => {
this._onResumeInterval();
}, delay2);
}
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, reject2) => {
const run = /* @__PURE__ */ __name(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) {
reject2(timeoutError);
}
return void 0;
});
resolve(await operation);
} catch (error2) {
reject2(error2);
}
this._next();
}, "run");
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;
}
});
// node_modules/langsmith/dist/singletons/fetch.cjs
var require_fetch = __commonJS({
"node_modules/langsmith/dist/singletons/fetch.cjs"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports._getFetchImplementation = exports.overrideFetchImplementation = void 0;
var DEFAULT_FETCH_IMPLEMENTATION = /* @__PURE__ */ __name((...args) => fetch(...args), "DEFAULT_FETCH_IMPLEMENTATION");
var LANGSMITH_FETCH_IMPLEMENTATION_KEY = Symbol.for("ls:fetch_implementation");
var overrideFetchImplementation = /* @__PURE__ */ __name((fetch2) => {
globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] = fetch2;
}, "overrideFetchImplementation");
exports.overrideFetchImplementation = overrideFetchImplementation;
var _getFetchImplementation = /* @__PURE__ */ __name(() => {
return globalThis[LANGSMITH_FETCH_IMPLEMENTATION_KEY] ?? DEFAULT_FETCH_IMPLEMENTATION;
}, "_getFetchImplementation");
exports._getFetchImplementation = _getFetchImplementation;
}
});
// node_modules/langsmith/dist/utils/async_caller.cjs
var require_async_caller = __commonJS({
"node_modules/langsmith/dist/utils/async_caller.cjs"(exports) {
"use strict";
var __importDefault = exports && exports.__importDefault || function(mod) {
return mod && mod.__esModule ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsyncCaller = void 0;
var p_retry_1 = __importDefault(require_p_retry());
var p_queue_1 = __importDefault(require_dist());
var fetch_js_1 = require_fetch();
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 {
static {
__name(this, "AsyncCaller");
}
constructor(params) {
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 = params.maxConcurrency ?? Infinity;
this.maxRetries = params.maxRetries ?? 6;
if ("default" in p_queue_1.default) {
this.queue = new p_queue_1.default.default({
concurrency: this.maxConcurrency
});
} else {
this.queue = new p_queue_1.default({ concurrency: this.maxConcurrency });
}
this.onFailedResponseHook = params?.onFailedResponseHook;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
call(callable, ...args) {
const onFailedResponseHook = this.onFailedResponseHook;
return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch((error2) => {
if (error2 instanceof Error) {
throw error2;
} else {
throw new Error(error2);
}
}), {
async onFailedAttempt(error2) {
if (error2.message.startsWith("Cancel") || error2.message.startsWith("TimeoutError") || error2.message.startsWith("AbortError")) {
throw error2;
}
if (error2?.code === "ECONNABORTED") {
throw error2;
}
const response = error2?.response;
const status = response?.status;
if (status) {
if (STATUS_NO_RETRY.includes(+status)) {
throw error2;
} 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((_, reject2) => {
options.signal?.addEventListener("abort", () => {
reject2(new Error("AbortError"));
});
})
]);
}
return this.call(callable, ...args);
}
fetch(...args) {
return this.call(() => (0, fetch_js_1._getFetchImplementation)()(...args).then((res) => res.ok ? res : Promise.reject(res)));
}
};
exports.AsyncCaller = AsyncCaller;
}
});
// node_modules/langsmith/dist/utils/messages.cjs
var require_messages = __commonJS({
"node_modules/langsmith/dist/utils/messages.cjs"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isLangChainMessage = isLangChainMessage;
exports.convertLangChainMessageToExample = convertLangChainMessageToExample;
function isLangChainMessage(message) {
return typeof message?._getType === "function";
}
__name(isLangChainMessage, "isLangChainMessage");
function convertLangChainMessageToExample(message) {
const converted = {
type: message._getType(),
data: { content: message.content }
};
if (message?.additional_kwargs && Object.keys(message.additional_kwargs).length > 0) {
converted.data.additional_kwargs = { ...message.additional_kwargs };
}
return converted;
}
__name(convertLangChainMessageToExample, "convertLangChainMessageToExample");
}
});
// node_modules/langsmith/dist/utils/_uuid.cjs
var require_uuid = __commonJS({
"node_modules/langsmith/dist/utils/_uuid.cjs"(exports) {
"use strict";
var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: /* @__PURE__ */ __name(function() {
return m[k];
}, "get") };
}
Object.defineProperty(o, k2, desc);
} : function(o, m, k, k2) {
if (k2 === void 0) k2 = k;
o[k2] = m[k];
});
var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
} : function(o, v) {
o["default"] = v;
});
var __importStar = exports && exports.__importStar || /* @__PURE__ */ function() {
var ownKeys = /* @__PURE__ */ __name(function(o) {
ownKeys = Object.getOwnPropertyNames || function(o2) {
var ar = [];
for (var k in o2) if (Object.prototype.hasOwnProperty.call(o2, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
}, "ownKeys");
return function(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) {
for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
}
__setModuleDefault(result, mod);
return result;
};
}();
Object.defineProperty(exports, "__esModule", { value: true });
exports.assertUuid = assertUuid;
var uuid4 = __importStar(__require("uuid"));
function assertUuid(str, which) {
if (!uuid4.validate(str)) {
const msg = which !== void 0 ? `Invalid UUID for ${which}: ${str}` : `Invalid UUID: ${str}`;
throw new Error(msg);
}
return str;
}
__name(assertUuid, "assertUuid");
}
});
// node_modules/langsmith/dist/utils/warn.cjs
var require_warn = __commonJS({
"node_modules/langsmith/dist/utils/warn.cjs"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.warnOnce = warnOnce;
var warnedMessages = {};
function warnOnce(message) {
if (!warnedMessages[message]) {
console.warn(message);
warnedMessages[message] = true;
}
}
__name(warnOnce, "warnOnce");
}
});
// node_modules/semver/internal/constants.js
var require_constants = __commonJS({
"node_modules/semver/internal/constants.js"(exports, module) {
"use strict";
var SEMVER_SPEC_VERSION = "2.0.0";
var MAX_LENGTH = 256;
var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
9007199254740991;
var MAX_SAFE_COMPONENT_LENGTH = 16;
var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
var RELEASE_TYPES = [
"major",
"premajor",
"minor",
"preminor",
"patch",
"prepatch",
"prerelease"
];
module.exports = {
MAX_LENGTH,
MAX_SAFE_COMPONENT_LENGTH,
MAX_SAFE_BUILD_LENGTH,
MAX_SAFE_INTEGER,
RELEASE_TYPES,
SEMVER_SPEC_VERSION,
FLAG_INCLUDE_PRERELEASE: 1,
FLAG_LOOSE: 2
};
}
});
// node_modules/semver/internal/debug.js
var require_debug = __commonJS({
"node_modules/semver/internal/debug.js"(exports, module) {
"use strict";
var debug2 = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
};
module.exports = debug2;
}
});
// node_modules/semver/internal/re.js
var require_re = __commonJS({
"node_modules/semver/internal/re.js"(exports, module) {
"use strict";
var { MAX_SAFE_COMPONENT_LENGTH, MAX_SAFE_BUILD_LENGTH, MAX_LENGTH } = require_constants();
var debug2 = require_debug();
exports = module.exports = {};
var re = exports.re = [];
var safeRe = exports.safeRe = [];
var src = exports.src = [];
var safeSrc = exports.safeSrc = [];
var t = exports.t = {};
var R = 0;
var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
var safeRegexReplacements = [
[
"\\s",
1
],
[
"\\d",
MAX_LENGTH
],
[
LETTERDASHNUMBER,
MAX_SAFE_BUILD_LENGTH
]
];
var makeSafeRegex = /* @__PURE__ */ __name((value) => {
for (const [token, max] of safeRegexReplacements) {
value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
}
return value;
}, "makeSafeRegex");
var createToken = /* @__PURE__ */ __name((name, value, isGlobal) => {
const safe = makeSafeRegex(value);
const index = R++;
debug2(name, index, value);
t[name] = index;
src[index] = value;
safeSrc[index] = safe;
re[index] = new RegExp(value, isGlobal ? "g" : void 0);
safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
}, "createToken");
createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
createToken("FULL", `^${src[t.FULLPLAIN]}$`);
createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
createToken("GTLT", "((?:<|>)?=?)");
createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
createToken("COERCE", `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
createToken("COERCEFULL", src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?(?:${src[t.BUILD]})?(?:$|[^\\d])`);
cre