@toolforge-js/sdk 0.3.0 → 0.4.0

package/dist/agent-DBDnKm26.js

@@ -0,0 +1,3093 @@
+import { createRequire } from "node:module";
+import * as z$1 from "zod";
+import { P, match } from "ts-pattern";
+import { setTimeout } from "node:timers/promises";
+import { nanoid } from "nanoid";
+
+//#region rolldown:runtime
+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 __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys$1 = __getOwnPropNames(from), i = 0, n = keys$1.length, key; i < n; i++) {
+		key = keys$1[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../../node_modules/.bun/dayjs@1.11.18/node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = /* @__PURE__ */ __commonJS({ "../../node_modules/.bun/dayjs@1.11.18/node_modules/dayjs/dayjs.min.js": ((exports, module) => {
+	(function(t, e) {
+		"object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+	})(exports, (function() {
+		var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = {
+			name: "en",
+			weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),
+			months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"),
+			ordinal: function(t$1) {
+				var e$1 = [
+					"th",
+					"st",
+					"nd",
+					"rd"
+				], n$1 = t$1 % 100;
+				return "[" + t$1 + (e$1[(n$1 - 20) % 10] || e$1[n$1] || e$1[0]) + "]";
+			}
+		}, m = function(t$1, e$1, n$1) {
+			var r$1 = String(t$1);
+			return !r$1 || r$1.length >= e$1 ? t$1 : "" + Array(e$1 + 1 - r$1.length).join(n$1) + t$1;
+		}, v = {
+			s: m,
+			z: function(t$1) {
+				var e$1 = -t$1.utcOffset(), n$1 = Math.abs(e$1), r$1 = Math.floor(n$1 / 60), i$1 = n$1 % 60;
+				return (e$1 <= 0 ? "+" : "-") + m(r$1, 2, "0") + ":" + m(i$1, 2, "0");
+			},
+			m: function t$1(e$1, n$1) {
+				if (e$1.date() < n$1.date()) return -t$1(n$1, e$1);
+				var r$1 = 12 * (n$1.year() - e$1.year()) + (n$1.month() - e$1.month()), i$1 = e$1.clone().add(r$1, c), s$1 = n$1 - i$1 < 0, u$1 = e$1.clone().add(r$1 + (s$1 ? -1 : 1), c);
+				return +(-(r$1 + (n$1 - i$1) / (s$1 ? i$1 - u$1 : u$1 - i$1)) || 0);
+			},
+			a: function(t$1) {
+				return t$1 < 0 ? Math.ceil(t$1) || 0 : Math.floor(t$1);
+			},
+			p: function(t$1) {
+				return {
+					M: c,
+					y: h,
+					w: o,
+					d: a,
+					D: d,
+					h: u,
+					m: s,
+					s: i,
+					ms: r,
+					Q: f
+				}[t$1] || String(t$1 || "").toLowerCase().replace(/s$/, "");
+			},
+			u: function(t$1) {
+				return void 0 === t$1;
+			}
+		}, g = "en", D = {};
+		D[g] = M;
+		var p = "$isDayjsObject", S = function(t$1) {
+			return t$1 instanceof _ || !(!t$1 || !t$1[p]);
+		}, w = function t$1(e$1, n$1, r$1) {
+			var i$1;
+			if (!e$1) return g;
+			if ("string" == typeof e$1) {
+				var s$1 = e$1.toLowerCase();
+				D[s$1] && (i$1 = s$1), n$1 && (D[s$1] = n$1, i$1 = s$1);
+				var u$1 = e$1.split("-");
+				if (!i$1 && u$1.length > 1) return t$1(u$1[0]);
+			} else {
+				var a$1 = e$1.name;
+				D[a$1] = e$1, i$1 = a$1;
+			}
+			return !r$1 && i$1 && (g = i$1), i$1 || !r$1 && g;
+		}, O = function(t$1, e$1) {
+			if (S(t$1)) return t$1.clone();
+			var n$1 = "object" == typeof e$1 ? e$1 : {};
+			return n$1.date = t$1, n$1.args = arguments, new _(n$1);
+		}, b = v;
+		b.l = w, b.i = S, b.w = function(t$1, e$1) {
+			return O(t$1, {
+				locale: e$1.$L,
+				utc: e$1.$u,
+				x: e$1.$x,
+				$offset: e$1.$offset
+			});
+		};
+		var _ = function() {
+			function M$1(t$1) {
+				this.$L = w(t$1.locale, null, !0), this.parse(t$1), this.$x = this.$x || t$1.x || {}, this[p] = !0;
+			}
+			var m$1 = M$1.prototype;
+			return m$1.parse = function(t$1) {
+				this.$d = function(t$2) {
+					var e$1 = t$2.date, n$1 = t$2.utc;
+					if (null === e$1) return /* @__PURE__ */ new Date(NaN);
+					if (b.u(e$1)) return /* @__PURE__ */ new Date();
+					if (e$1 instanceof Date) return new Date(e$1);
+					if ("string" == typeof e$1 && !/Z$/i.test(e$1)) {
+						var r$1 = e$1.match($);
+						if (r$1) {
+							var i$1 = r$1[2] - 1 || 0, s$1 = (r$1[7] || "0").substring(0, 3);
+							return n$1 ? new Date(Date.UTC(r$1[1], i$1, r$1[3] || 1, r$1[4] || 0, r$1[5] || 0, r$1[6] || 0, s$1)) : new Date(r$1[1], i$1, r$1[3] || 1, r$1[4] || 0, r$1[5] || 0, r$1[6] || 0, s$1);
+						}
+					}
+					return new Date(e$1);
+				}(t$1), this.init();
+			}, m$1.init = function() {
+				var t$1 = this.$d;
+				this.$y = t$1.getFullYear(), this.$M = t$1.getMonth(), this.$D = t$1.getDate(), this.$W = t$1.getDay(), this.$H = t$1.getHours(), this.$m = t$1.getMinutes(), this.$s = t$1.getSeconds(), this.$ms = t$1.getMilliseconds();
+			}, m$1.$utils = function() {
+				return b;
+			}, m$1.isValid = function() {
+				return !(this.$d.toString() === l);
+			}, m$1.isSame = function(t$1, e$1) {
+				var n$1 = O(t$1);
+				return this.startOf(e$1) <= n$1 && n$1 <= this.endOf(e$1);
+			}, m$1.isAfter = function(t$1, e$1) {
+				return O(t$1) < this.startOf(e$1);
+			}, m$1.isBefore = function(t$1, e$1) {
+				return this.endOf(e$1) < O(t$1);
+			}, m$1.$g = function(t$1, e$1, n$1) {
+				return b.u(t$1) ? this[e$1] : this.set(n$1, t$1);
+			}, m$1.unix = function() {
+				return Math.floor(this.valueOf() / 1e3);
+			}, m$1.valueOf = function() {
+				return this.$d.getTime();
+			}, m$1.startOf = function(t$1, e$1) {
+				var n$1 = this, r$1 = !!b.u(e$1) || e$1, f$1 = b.p(t$1), l$1 = function(t$2, e$2) {
+					var i$1 = b.w(n$1.$u ? Date.UTC(n$1.$y, e$2, t$2) : new Date(n$1.$y, e$2, t$2), n$1);
+					return r$1 ? i$1 : i$1.endOf(a);
+				}, $$1 = function(t$2, e$2) {
+					return b.w(n$1.toDate()[t$2].apply(n$1.toDate("s"), (r$1 ? [
+						0,
+						0,
+						0,
+						0
+					] : [
+						23,
+						59,
+						59,
+						999
+					]).slice(e$2)), n$1);
+				}, y$1 = this.$W, M$2 = this.$M, m$2 = this.$D, v$1 = "set" + (this.$u ? "UTC" : "");
+				switch (f$1) {
+					case h: return r$1 ? l$1(1, 0) : l$1(31, 11);
+					case c: return r$1 ? l$1(1, M$2) : l$1(0, M$2 + 1);
+					case o:
+						var g$1 = this.$locale().weekStart || 0, D$1 = (y$1 < g$1 ? y$1 + 7 : y$1) - g$1;
+						return l$1(r$1 ? m$2 - D$1 : m$2 + (6 - D$1), M$2);
+					case a:
+					case d: return $$1(v$1 + "Hours", 0);
+					case u: return $$1(v$1 + "Minutes", 1);
+					case s: return $$1(v$1 + "Seconds", 2);
+					case i: return $$1(v$1 + "Milliseconds", 3);
+					default: return this.clone();
+				}
+			}, m$1.endOf = function(t$1) {
+				return this.startOf(t$1, !1);
+			}, m$1.$set = function(t$1, e$1) {
+				var n$1, o$1 = b.p(t$1), f$1 = "set" + (this.$u ? "UTC" : ""), l$1 = (n$1 = {}, n$1[a] = f$1 + "Date", n$1[d] = f$1 + "Date", n$1[c] = f$1 + "Month", n$1[h] = f$1 + "FullYear", n$1[u] = f$1 + "Hours", n$1[s] = f$1 + "Minutes", n$1[i] = f$1 + "Seconds", n$1[r] = f$1 + "Milliseconds", n$1)[o$1], $$1 = o$1 === a ? this.$D + (e$1 - this.$W) : e$1;
+				if (o$1 === c || o$1 === h) {
+					var y$1 = this.clone().set(d, 1);
+					y$1.$d[l$1]($$1), y$1.init(), this.$d = y$1.set(d, Math.min(this.$D, y$1.daysInMonth())).$d;
+				} else l$1 && this.$d[l$1]($$1);
+				return this.init(), this;
+			}, m$1.set = function(t$1, e$1) {
+				return this.clone().$set(t$1, e$1);
+			}, m$1.get = function(t$1) {
+				return this[b.p(t$1)]();
+			}, m$1.add = function(r$1, f$1) {
+				var d$1, l$1 = this;
+				r$1 = Number(r$1);
+				var $$1 = b.p(f$1), y$1 = function(t$1) {
+					var e$1 = O(l$1);
+					return b.w(e$1.date(e$1.date() + Math.round(t$1 * r$1)), l$1);
+				};
+				if ($$1 === c) return this.set(c, this.$M + r$1);
+				if ($$1 === h) return this.set(h, this.$y + r$1);
+				if ($$1 === a) return y$1(1);
+				if ($$1 === o) return y$1(7);
+				var M$2 = (d$1 = {}, d$1[s] = e, d$1[u] = n, d$1[i] = t, d$1)[$$1] || 1, m$2 = this.$d.getTime() + r$1 * M$2;
+				return b.w(m$2, this);
+			}, m$1.subtract = function(t$1, e$1) {
+				return this.add(-1 * t$1, e$1);
+			}, m$1.format = function(t$1) {
+				var e$1 = this, n$1 = this.$locale();
+				if (!this.isValid()) return n$1.invalidDate || l;
+				var r$1 = t$1 || "YYYY-MM-DDTHH:mm:ssZ", i$1 = b.z(this), s$1 = this.$H, u$1 = this.$m, a$1 = this.$M, o$1 = n$1.weekdays, c$1 = n$1.months, f$1 = n$1.meridiem, h$1 = function(t$2, n$2, i$2, s$2) {
+					return t$2 && (t$2[n$2] || t$2(e$1, r$1)) || i$2[n$2].slice(0, s$2);
+				}, d$1 = function(t$2) {
+					return b.s(s$1 % 12 || 12, t$2, "0");
+				}, $$1 = f$1 || function(t$2, e$2, n$2) {
+					var r$2 = t$2 < 12 ? "AM" : "PM";
+					return n$2 ? r$2.toLowerCase() : r$2;
+				};
+				return r$1.replace(y, (function(t$2, r$2) {
+					return r$2 || function(t$3) {
+						switch (t$3) {
+							case "YY": return String(e$1.$y).slice(-2);
+							case "YYYY": return b.s(e$1.$y, 4, "0");
+							case "M": return a$1 + 1;
+							case "MM": return b.s(a$1 + 1, 2, "0");
+							case "MMM": return h$1(n$1.monthsShort, a$1, c$1, 3);
+							case "MMMM": return h$1(c$1, a$1);
+							case "D": return e$1.$D;
+							case "DD": return b.s(e$1.$D, 2, "0");
+							case "d": return String(e$1.$W);
+							case "dd": return h$1(n$1.weekdaysMin, e$1.$W, o$1, 2);
+							case "ddd": return h$1(n$1.weekdaysShort, e$1.$W, o$1, 3);
+							case "dddd": return o$1[e$1.$W];
+							case "H": return String(s$1);
+							case "HH": return b.s(s$1, 2, "0");
+							case "h": return d$1(1);
+							case "hh": return d$1(2);
+							case "a": return $$1(s$1, u$1, !0);
+							case "A": return $$1(s$1, u$1, !1);
+							case "m": return String(u$1);
+							case "mm": return b.s(u$1, 2, "0");
+							case "s": return String(e$1.$s);
+							case "ss": return b.s(e$1.$s, 2, "0");
+							case "SSS": return b.s(e$1.$ms, 3, "0");
+							case "Z": return i$1;
+						}
+						return null;
+					}(t$2) || i$1.replace(":", "");
+				}));
+			}, m$1.utcOffset = function() {
+				return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+			}, m$1.diff = function(r$1, d$1, l$1) {
+				var $$1, y$1 = this, M$2 = b.p(d$1), m$2 = O(r$1), v$1 = (m$2.utcOffset() - this.utcOffset()) * e, g$1 = this - m$2, D$1 = function() {
+					return b.m(y$1, m$2);
+				};
+				switch (M$2) {
+					case h:
+						$$1 = D$1() / 12;
+						break;
+					case c:
+						$$1 = D$1();
+						break;
+					case f:
+						$$1 = D$1() / 3;
+						break;
+					case o:
+						$$1 = (g$1 - v$1) / 6048e5;
+						break;
+					case a:
+						$$1 = (g$1 - v$1) / 864e5;
+						break;
+					case u:
+						$$1 = g$1 / n;
+						break;
+					case s:
+						$$1 = g$1 / e;
+						break;
+					case i:
+						$$1 = g$1 / t;
+						break;
+					default: $$1 = g$1;
+				}
+				return l$1 ? $$1 : b.a($$1);
+			}, m$1.daysInMonth = function() {
+				return this.endOf(c).$D;
+			}, m$1.$locale = function() {
+				return D[this.$L];
+			}, m$1.locale = function(t$1, e$1) {
+				if (!t$1) return this.$L;
+				var n$1 = this.clone(), r$1 = w(t$1, e$1, !0);
+				return r$1 && (n$1.$L = r$1), n$1;
+			}, m$1.clone = function() {
+				return b.w(this.$d, this);
+			}, m$1.toDate = function() {
+				return new Date(this.valueOf());
+			}, m$1.toJSON = function() {
+				return this.isValid() ? this.toISOString() : null;
+			}, m$1.toISOString = function() {
+				return this.$d.toISOString();
+			}, m$1.toString = function() {
+				return this.$d.toUTCString();
+			}, M$1;
+		}(), k = _.prototype;
+		return O.prototype = k, [
+			["$ms", r],
+			["$s", i],
+			["$m", s],
+			["$H", u],
+			["$W", a],
+			["$M", c],
+			["$y", h],
+			["$D", d]
+		].forEach((function(t$1) {
+			k[t$1[1]] = function(e$1) {
+				return this.$g(e$1, t$1[0], t$1[1]);
+			};
+		})), O.extend = function(t$1, e$1) {
+			return t$1.$i || (t$1(e$1, _, O), t$1.$i = !0), O;
+		}, O.locale = w, O.isDayjs = S, O.unix = function(t$1) {
+			return O(1e3 * t$1);
+		}, O.en = D[g], O.Ls = D, O.p = {}, O;
+	}));
+}) });
+
+//#endregion
+//#region ../../node_modules/.bun/fast-equals@5.2.2/node_modules/fast-equals/dist/esm/index.mjs
+var getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+/**
+* Combine two comparators into a single comparators.
+*/
+function combineComparators(comparatorA, comparatorB) {
+	return function isEqual(a, b, state) {
+		return comparatorA(a, b, state) && comparatorB(a, b, state);
+	};
+}
+/**
+* Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+* for circular references to be safely included in the comparison without creating
+* stack overflows.
+*/
+function createIsCircular(areItemsEqual) {
+	return function isCircular(a, b, state) {
+		if (!a || !b || typeof a !== "object" || typeof b !== "object") return areItemsEqual(a, b, state);
+		var cache = state.cache;
+		var cachedA = cache.get(a);
+		var cachedB = cache.get(b);
+		if (cachedA && cachedB) return cachedA === b && cachedB === a;
+		cache.set(a, b);
+		cache.set(b, a);
+		var result = areItemsEqual(a, b, state);
+		cache.delete(a);
+		cache.delete(b);
+		return result;
+	};
+}
+/**
+* Get the properties to strictly examine, which include both own properties that are
+* not enumerable and symbol properties.
+*/
+function getStrictProperties(object) {
+	return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+}
+/**
+* Whether the object contains the property passed as an own property.
+*/
+var hasOwn = Object.hasOwn || (function(object, property) {
+	return hasOwnProperty.call(object, property);
+});
+/**
+* Whether the values passed are strictly equal or both NaN.
+*/
+function sameValueZeroEqual(a, b) {
+	return a === b || !a && !b && a !== a && b !== b;
+}
+var PREACT_VNODE = "__v";
+var PREACT_OWNER = "__o";
+var REACT_OWNER = "_owner";
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, keys = Object.keys;
+/**
+* Whether the arrays are equal in value.
+*/
+function areArraysEqual(a, b, state) {
+	var index = a.length;
+	if (b.length !== index) return false;
+	while (index-- > 0) if (!state.equals(a[index], b[index], index, index, a, b, state)) return false;
+	return true;
+}
+/**
+* Whether the dates passed are equal in value.
+*/
+function areDatesEqual(a, b) {
+	return sameValueZeroEqual(a.getTime(), b.getTime());
+}
+/**
+* Whether the errors passed are equal in value.
+*/
+function areErrorsEqual(a, b) {
+	return a.name === b.name && a.message === b.message && a.cause === b.cause && a.stack === b.stack;
+}
+/**
+* Whether the functions passed are equal in value.
+*/
+function areFunctionsEqual(a, b) {
+	return a === b;
+}
+/**
+* Whether the `Map`s are equal in value.
+*/
+function areMapsEqual(a, b, state) {
+	var size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	var matchedIndices = new Array(size);
+	var aIterable = a.entries();
+	var aResult;
+	var bResult;
+	var index = 0;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		var bIterable = b.entries();
+		var hasMatch = false;
+		var matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (matchedIndices[matchIndex]) {
+				matchIndex++;
+				continue;
+			}
+			var aEntry = aResult.value;
+			var bEntry = bResult.value;
+			if (state.equals(aEntry[0], bEntry[0], index, matchIndex, a, b, state) && state.equals(aEntry[1], bEntry[1], aEntry[0], bEntry[0], a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+		index++;
+	}
+	return true;
+}
+/**
+* Whether the numbers are equal in value.
+*/
+var areNumbersEqual = sameValueZeroEqual;
+/**
+* Whether the objects are equal in value.
+*/
+function areObjectsEqual(a, b, state) {
+	var properties = keys(a);
+	var index = properties.length;
+	if (keys(b).length !== index) return false;
+	while (index-- > 0) if (!isPropertyEqual(a, b, state, properties[index])) return false;
+	return true;
+}
+/**
+* Whether the objects are equal in value with strict property checking.
+*/
+function areObjectsEqualStrict(a, b, state) {
+	var properties = getStrictProperties(a);
+	var index = properties.length;
+	if (getStrictProperties(b).length !== index) return false;
+	var property;
+	var descriptorA;
+	var descriptorB;
+	while (index-- > 0) {
+		property = properties[index];
+		if (!isPropertyEqual(a, b, state, property)) return false;
+		descriptorA = getOwnPropertyDescriptor(a, property);
+		descriptorB = getOwnPropertyDescriptor(b, property);
+		if ((descriptorA || descriptorB) && (!descriptorA || !descriptorB || descriptorA.configurable !== descriptorB.configurable || descriptorA.enumerable !== descriptorB.enumerable || descriptorA.writable !== descriptorB.writable)) return false;
+	}
+	return true;
+}
+/**
+* Whether the primitive wrappers passed are equal in value.
+*/
+function arePrimitiveWrappersEqual(a, b) {
+	return sameValueZeroEqual(a.valueOf(), b.valueOf());
+}
+/**
+* Whether the regexps passed are equal in value.
+*/
+function areRegExpsEqual(a, b) {
+	return a.source === b.source && a.flags === b.flags;
+}
+/**
+* Whether the `Set`s are equal in value.
+*/
+function areSetsEqual(a, b, state) {
+	var size = a.size;
+	if (size !== b.size) return false;
+	if (!size) return true;
+	var matchedIndices = new Array(size);
+	var aIterable = a.values();
+	var aResult;
+	var bResult;
+	while (aResult = aIterable.next()) {
+		if (aResult.done) break;
+		var bIterable = b.values();
+		var hasMatch = false;
+		var matchIndex = 0;
+		while (bResult = bIterable.next()) {
+			if (bResult.done) break;
+			if (!matchedIndices[matchIndex] && state.equals(aResult.value, bResult.value, aResult.value, bResult.value, a, b, state)) {
+				hasMatch = matchedIndices[matchIndex] = true;
+				break;
+			}
+			matchIndex++;
+		}
+		if (!hasMatch) return false;
+	}
+	return true;
+}
+/**
+* Whether the TypedArray instances are equal in value.
+*/
+function areTypedArraysEqual(a, b) {
+	var index = a.length;
+	if (b.length !== index) return false;
+	while (index-- > 0) if (a[index] !== b[index]) return false;
+	return true;
+}
+/**
+* Whether the URL instances are equal in value.
+*/
+function areUrlsEqual(a, b) {
+	return a.hostname === b.hostname && a.pathname === b.pathname && a.protocol === b.protocol && a.port === b.port && a.hash === b.hash && a.username === b.username && a.password === b.password;
+}
+function isPropertyEqual(a, b, state, property) {
+	if ((property === REACT_OWNER || property === PREACT_OWNER || property === PREACT_VNODE) && (a.$$typeof || b.$$typeof)) return true;
+	return hasOwn(b, property) && state.equals(a[property], b[property], property, property, a, b, state);
+}
+var ARGUMENTS_TAG = "[object Arguments]";
+var BOOLEAN_TAG = "[object Boolean]";
+var DATE_TAG = "[object Date]";
+var ERROR_TAG = "[object Error]";
+var MAP_TAG = "[object Map]";
+var NUMBER_TAG = "[object Number]";
+var OBJECT_TAG = "[object Object]";
+var REG_EXP_TAG = "[object RegExp]";
+var SET_TAG = "[object Set]";
+var STRING_TAG = "[object String]";
+var URL_TAG = "[object URL]";
+var isArray = Array.isArray;
+var isTypedArray = typeof ArrayBuffer === "function" && ArrayBuffer.isView ? ArrayBuffer.isView : null;
+var assign = Object.assign;
+var getTag = Object.prototype.toString.call.bind(Object.prototype.toString);
+/**
+* Create a comparator method based on the type-specific equality comparators passed.
+*/
+function createEqualityComparator(_a) {
+	var areArraysEqual$1 = _a.areArraysEqual, areDatesEqual$1 = _a.areDatesEqual, areErrorsEqual$1 = _a.areErrorsEqual, areFunctionsEqual$1 = _a.areFunctionsEqual, areMapsEqual$1 = _a.areMapsEqual, areNumbersEqual$1 = _a.areNumbersEqual, areObjectsEqual$1 = _a.areObjectsEqual, arePrimitiveWrappersEqual$1 = _a.arePrimitiveWrappersEqual, areRegExpsEqual$1 = _a.areRegExpsEqual, areSetsEqual$1 = _a.areSetsEqual, areTypedArraysEqual$1 = _a.areTypedArraysEqual, areUrlsEqual$1 = _a.areUrlsEqual;
+	/**
+	* compare the value of the two objects and return true if they are equivalent in values
+	*/
+	return function comparator(a, b, state) {
+		if (a === b) return true;
+		if (a == null || b == null) return false;
+		var type = typeof a;
+		if (type !== typeof b) return false;
+		if (type !== "object") {
+			if (type === "number") return areNumbersEqual$1(a, b, state);
+			if (type === "function") return areFunctionsEqual$1(a, b, state);
+			return false;
+		}
+		var constructor = a.constructor;
+		if (constructor !== b.constructor) return false;
+		if (constructor === Object) return areObjectsEqual$1(a, b, state);
+		if (isArray(a)) return areArraysEqual$1(a, b, state);
+		if (isTypedArray != null && isTypedArray(a)) return areTypedArraysEqual$1(a, b, state);
+		if (constructor === Date) return areDatesEqual$1(a, b, state);
+		if (constructor === RegExp) return areRegExpsEqual$1(a, b, state);
+		if (constructor === Map) return areMapsEqual$1(a, b, state);
+		if (constructor === Set) return areSetsEqual$1(a, b, state);
+		var tag = getTag(a);
+		if (tag === DATE_TAG) return areDatesEqual$1(a, b, state);
+		if (tag === REG_EXP_TAG) return areRegExpsEqual$1(a, b, state);
+		if (tag === MAP_TAG) return areMapsEqual$1(a, b, state);
+		if (tag === SET_TAG) return areSetsEqual$1(a, b, state);
+		if (tag === OBJECT_TAG) return typeof a.then !== "function" && typeof b.then !== "function" && areObjectsEqual$1(a, b, state);
+		if (tag === URL_TAG) return areUrlsEqual$1(a, b, state);
+		if (tag === ERROR_TAG) return areErrorsEqual$1(a, b, state);
+		if (tag === ARGUMENTS_TAG) return areObjectsEqual$1(a, b, state);
+		if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) return arePrimitiveWrappersEqual$1(a, b, state);
+		return false;
+	};
+}
+/**
+* Create the configuration object used for building comparators.
+*/
+function createEqualityComparatorConfig(_a) {
+	var circular = _a.circular, createCustomConfig = _a.createCustomConfig, strict = _a.strict;
+	var config = {
+		areArraysEqual: strict ? areObjectsEqualStrict : areArraysEqual,
+		areDatesEqual,
+		areErrorsEqual,
+		areFunctionsEqual,
+		areMapsEqual: strict ? combineComparators(areMapsEqual, areObjectsEqualStrict) : areMapsEqual,
+		areNumbersEqual,
+		areObjectsEqual: strict ? areObjectsEqualStrict : areObjectsEqual,
+		arePrimitiveWrappersEqual,
+		areRegExpsEqual,
+		areSetsEqual: strict ? combineComparators(areSetsEqual, areObjectsEqualStrict) : areSetsEqual,
+		areTypedArraysEqual: strict ? areObjectsEqualStrict : areTypedArraysEqual,
+		areUrlsEqual
+	};
+	if (createCustomConfig) config = assign({}, config, createCustomConfig(config));
+	if (circular) {
+		var areArraysEqual$1 = createIsCircular(config.areArraysEqual);
+		var areMapsEqual$1 = createIsCircular(config.areMapsEqual);
+		var areObjectsEqual$1 = createIsCircular(config.areObjectsEqual);
+		var areSetsEqual$1 = createIsCircular(config.areSetsEqual);
+		config = assign({}, config, {
+			areArraysEqual: areArraysEqual$1,
+			areMapsEqual: areMapsEqual$1,
+			areObjectsEqual: areObjectsEqual$1,
+			areSetsEqual: areSetsEqual$1
+		});
+	}
+	return config;
+}
+/**
+* Default equality comparator pass-through, used as the standard `isEqual` creator for
+* use inside the built comparator.
+*/
+function createInternalEqualityComparator(compare) {
+	return function(a, b, _indexOrKeyA, _indexOrKeyB, _parentA, _parentB, state) {
+		return compare(a, b, state);
+	};
+}
+/**
+* Create the `isEqual` function used by the consuming application.
+*/
+function createIsEqual(_a) {
+	var circular = _a.circular, comparator = _a.comparator, createState = _a.createState, equals = _a.equals, strict = _a.strict;
+	if (createState) return function isEqual(a, b) {
+		var _a$1 = createState(), _b = _a$1.cache, cache = _b === void 0 ? circular ? /* @__PURE__ */ new WeakMap() : void 0 : _b, meta = _a$1.meta;
+		return comparator(a, b, {
+			cache,
+			equals,
+			meta,
+			strict
+		});
+	};
+	if (circular) return function isEqual(a, b) {
+		return comparator(a, b, {
+			cache: /* @__PURE__ */ new WeakMap(),
+			equals,
+			meta: void 0,
+			strict
+		});
+	};
+	var state = {
+		cache: void 0,
+		equals,
+		meta: void 0,
+		strict
+	};
+	return function isEqual(a, b) {
+		return comparator(a, b, state);
+	};
+}
+/**
+* Whether the items passed are deeply-equal in value.
+*/
+var deepEqual = createCustomEqual();
+/**
+* Whether the items passed are deeply-equal in value based on strict comparison.
+*/
+var strictDeepEqual = createCustomEqual({ strict: true });
+/**
+* Whether the items passed are deeply-equal in value, including circular references.
+*/
+var circularDeepEqual = createCustomEqual({ circular: true });
+/**
+* Whether the items passed are deeply-equal in value, including circular references,
+* based on strict comparison.
+*/
+var strictCircularDeepEqual = createCustomEqual({
+	circular: true,
+	strict: true
+});
+/**
+* Whether the items passed are shallowly-equal in value.
+*/
+var shallowEqual = createCustomEqual({ createInternalComparator: function() {
+	return sameValueZeroEqual;
+} });
+/**
+* Whether the items passed are shallowly-equal in value based on strict comparison
+*/
+var strictShallowEqual = createCustomEqual({
+	strict: true,
+	createInternalComparator: function() {
+		return sameValueZeroEqual;
+	}
+});
+/**
+* Whether the items passed are shallowly-equal in value, including circular references.
+*/
+var circularShallowEqual = createCustomEqual({
+	circular: true,
+	createInternalComparator: function() {
+		return sameValueZeroEqual;
+	}
+});
+/**
+* Whether the items passed are shallowly-equal in value, including circular references,
+* based on strict comparison.
+*/
+var strictCircularShallowEqual = createCustomEqual({
+	circular: true,
+	createInternalComparator: function() {
+		return sameValueZeroEqual;
+	},
+	strict: true
+});
+/**
+* Create a custom equality comparison method.
+*
+* This can be done to create very targeted comparisons in extreme hot-path scenarios
+* where the standard methods are not performant enough, but can also be used to provide
+* support for legacy environments that do not support expected features like
+* `RegExp.prototype.flags` out of the box.
+*/
+function createCustomEqual(options) {
+	if (options === void 0) options = {};
+	var _a = options.circular, circular = _a === void 0 ? false : _a, createCustomInternalComparator = options.createInternalComparator, createState = options.createState, _b = options.strict, strict = _b === void 0 ? false : _b;
+	var comparator = createEqualityComparator(createEqualityComparatorConfig(options));
+	return createIsEqual({
+		circular,
+		comparator,
+		createState,
+		equals: createCustomInternalComparator ? createCustomInternalComparator(comparator) : createInternalEqualityComparator(comparator),
+		strict
+	});
+}
+
+//#endregion
+//#region ../core/dist/schema/index.js
+var import_dayjs_min = /* @__PURE__ */ __toESM(require_dayjs_min(), 1);
+const workflowEdgeSchema = z$1.discriminatedUnion("type", [z$1.object({
+	type: z$1.literal("flow"),
+	from: z$1.string(),
+	to: z$1.string()
+}), z$1.object({
+	type: z$1.literal("branch"),
+	from: z$1.string(),
+	targetMap: z$1.record(z$1.string(), z$1.string())
+})]);
+const agentWorkflowSchema = z$1.object({
+	nodes: z$1.string().array(),
+	edges: workflowEdgeSchema.array()
+});
+const primitiveSchema = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.bigint()
+]);
+const dataRecord = z$1.record(z$1.string(), primitiveSchema.nullable().optional());
+const chartDataItemSchema = z$1.record(z$1.string(), z$1.any());
+const chartDataSchema = chartDataItemSchema.array();
+const colorString = z$1.string().refine((value) => {
+	const color = value.trim().toLowerCase();
+	return /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/.test(color) || /^rgba?\(\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)\s*,\s*(\d+(?:\.\d+)?%?)(?:\s*,\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color) || /^hsla?\(\s*(\d+(?:\.\d+)?(?:deg|grad|rad|turn)?)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%)(?:\s*,\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color) || /^oklch\(\s*(\d+(?:\.\d+)?%?)\s+(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)(?:\s*\/\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color) || /^oklab\(\s*(\d+(?:\.\d+)?%?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s*\/\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color) || /^lab\(\s*(\d+(?:\.\d+)?%?)\s+(-?\d+(?:\.\d+)?)\s+(-?\d+(?:\.\d+)?)(?:\s*\/\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color) || /^lch\(\s*(\d+(?:\.\d+)?%?)\s+(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)(?:\s*\/\s*(\d+(?:\.\d+)?%?))?\s*\)$/.test(color);
+});
+const availableColors = z$1.enum([
+	"blue",
+	"emerald",
+	"violet",
+	"amber",
+	"gray",
+	"cyan",
+	"pink",
+	"lime",
+	"fuchsia",
+	"red",
+	"green",
+	"yellow"
+]);
+const chartColor = z$1.union([availableColors, colorString]);
+const baseChartSchema = z$1.object({
+	type: z$1.literal("chart"),
+	title: z$1.string().optional(),
+	description: z$1.string().optional()
+});
+const valueFormatSchema = z$1.object({
+	type: z$1.enum([
+		"number",
+		"currency",
+		"percentage"
+	]).optional().default("number").describe("Type of value formatting to apply"),
+	decimals: z$1.number().min(0).max(10).optional().default(0).describe("Precision control"),
+	currency: z$1.string().optional().default("USD"),
+	currencyDisplay: z$1.enum([
+		"symbol",
+		"code",
+		"name"
+	]).optional().default("symbol"),
+	thousandsSeparator: z$1.string().optional().default(","),
+	decimalSeparator: z$1.string().optional().default("."),
+	prefix: z$1.string().optional(),
+	suffix: z$1.string().optional(),
+	showPercentageSymbol: z$1.boolean().optional().default(true),
+	locale: z$1.string().optional().default("en-US"),
+	notation: z$1.enum(["standard", "compact"]).optional().default("standard")
+});
+const areaChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("area-chart"),
+	data: chartDataSchema,
+	index: z$1.string().describe("key of the data object to map the data to the x axis"),
+	categories: z$1.string().array().describe("select the categories from your data"),
+	colors: chartColor.array().optional().default(["blue"]),
+	xAxisLabel: z$1.string().optional(),
+	yAxisLabel: z$1.string().optional(),
+	fillType: z$1.enum([
+		"gradient",
+		"solid",
+		"none"
+	]).optional().default("gradient"),
+	stackType: z$1.enum([
+		"default",
+		"stacked",
+		"percent"
+	]).optional().default("default"),
+	intervalType: z$1.enum(["equidistantPreserveStart", "preserveStartEnd"]).optional().describe("Controls the interval logic of x-axis and how ticks and labels are placed").default("equidistantPreserveStart"),
+	startEndOnly: z$1.boolean().optional().default(false),
+	showXAxis: z$1.boolean().optional().default(true),
+	showYAxis: z$1.boolean().optional().default(true),
+	showGridLines: z$1.boolean().optional().default(true),
+	showTooltip: z$1.boolean().optional().default(true),
+	showLegend: z$1.boolean().optional().default(true),
+	valueFormat: valueFormatSchema.optional()
+});
+const barChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("bar-chart"),
+	data: chartDataSchema,
+	index: z$1.string().describe("key of the data object to map the data to the x axis"),
+	categories: z$1.string().array().describe("select the categories from your data"),
+	colors: chartColor.array().optional().default(["blue"]),
+	xAxisLabel: z$1.string().optional(),
+	yAxisLabel: z$1.string().optional(),
+	stackType: z$1.enum([
+		"default",
+		"stacked",
+		"percent"
+	]).optional().default("default"),
+	startEndOnly: z$1.boolean().optional().default(false),
+	intervalType: z$1.enum(["equidistantPreserveStart", "preserveStartEnd"]).optional().describe("Controls the interval logic of x-axis and how ticks and labels are placed").default("equidistantPreserveStart"),
+	showXAxis: z$1.boolean().optional().default(true),
+	showYAxis: z$1.boolean().optional().default(true),
+	showGridLines: z$1.boolean().optional().default(true),
+	showTooltip: z$1.boolean().optional().default(true),
+	showLegend: z$1.boolean().optional().default(true),
+	valueFormat: valueFormatSchema.optional(),
+	layout: z$1.enum(["horizontal", "vertical"]).optional().default("horizontal")
+});
+const barListSchema = baseChartSchema.extend({
+	chartType: z$1.literal("bar-list"),
+	data: z$1.object({
+		value: z$1.number(),
+		name: z$1.string()
+	}).array(),
+	sortOrder: z$1.enum([
+		"ascending",
+		"descending",
+		"none"
+	]).optional().default("descending"),
+	color: chartColor.optional().default("blue")
+});
+const categoryBarSchema = baseChartSchema.extend({
+	chartType: z$1.literal("category-bar"),
+	values: z$1.object({
+		value: z$1.number(),
+		label: z$1.string()
+	}).or(z$1.number()).array(),
+	colors: chartColor.array().optional().default(["blue"]),
+	marker: z$1.object({
+		value: z$1.number(),
+		name: z$1.string().optional()
+	}).optional(),
+	showLegend: z$1.boolean().optional().default(false),
+	showLabel: z$1.boolean().optional().default(true)
+});
+const donutChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("donut-chart"),
+	data: chartDataSchema,
+	category: z$1.string().describe("key of the data object to map the data to the categories"),
+	value: z$1.string().describe("select the value from your data"),
+	colors: chartColor.array().optional().default(["blue"]),
+	variant: z$1.enum(["donut", "pie"]).optional().default("donut"),
+	label: z$1.string().optional(),
+	showLabel: z$1.boolean().optional().default(false),
+	showTooltip: z$1.boolean().optional().default(true),
+	valueFormat: valueFormatSchema.optional()
+});
+const lineChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("line-chart"),
+	data: chartDataSchema,
+	index: z$1.string().describe("key of the data object to map the data to the x axis"),
+	categories: z$1.string().array().describe("select the categories from your data"),
+	colors: chartColor.array().optional().default(["blue"]),
+	xAxisLabel: z$1.string().optional(),
+	yAxisLabel: z$1.string().optional(),
+	intervalType: z$1.enum(["equidistantPreserveStart", "preserveStartEnd"]).optional().describe("Controls the interval logic of x-axis and how ticks and labels are placed").default("equidistantPreserveStart"),
+	startEndOnly: z$1.boolean().optional().default(false),
+	showXAxis: z$1.boolean().optional().default(true),
+	showYAxis: z$1.boolean().optional().default(true),
+	showGridLines: z$1.boolean().optional().default(true),
+	showTooltip: z$1.boolean().optional().default(true),
+	showLegend: z$1.boolean().optional().default(true),
+	valueFormat: valueFormatSchema.optional()
+});
+const progressBarSchema = baseChartSchema.extend({
+	chartType: z$1.literal("progress-bar"),
+	value: z$1.number(),
+	max: z$1.number(),
+	label: z$1.string().or(z$1.number()).optional(),
+	variant: z$1.enum([
+		"default",
+		"neutral",
+		"warning",
+		"error",
+		"success"
+	]).optional().default("default")
+});
+const progressCircleSchema = baseChartSchema.extend({
+	chartType: z$1.literal("progress-circle"),
+	value: z$1.number(),
+	max: z$1.number(),
+	radius: z$1.number().optional().default(32),
+	variant: z$1.enum([
+		"default",
+		"neutral",
+		"warning",
+		"error",
+		"success"
+	]).optional().default("default")
+});
+const sparkChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("spark-chart"),
+	data: chartDataSchema,
+	index: z$1.string().describe("key of the data object to map the data to the x axis"),
+	categories: z$1.string().array().describe("select the categories from your data"),
+	colors: chartColor.array().optional().default(["blue"]),
+	fillType: z$1.enum([
+		"gradient",
+		"solid",
+		"none"
+	]).optional().default("gradient"),
+	stackType: z$1.enum([
+		"default",
+		"stacked",
+		"percent"
+	]).optional().default("default"),
+	sparkChartType: z$1.enum([
+		"bar",
+		"area",
+		"line"
+	]).optional().default("area")
+});
+const trackerSchema = baseChartSchema.extend({
+	chartType: z$1.literal("tracker"),
+	data: z$1.object({
+		name: z$1.string(),
+		color: chartColor.optional().default("blue")
+	}).array(),
+	defaultBackgroundColor: chartColor.optional().default("gray")
+});
+const comboChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("combo-chart"),
+	data: chartDataSchema,
+	index: z$1.string().describe("key of the data object to map the data to the x axis"),
+	xAxisLabel: z$1.string().optional(),
+	showXAxis: z$1.boolean().optional().default(true),
+	showGridLines: z$1.boolean().optional().default(true),
+	showTooltip: z$1.boolean().optional().default(true),
+	showLegend: z$1.boolean().optional().default(true),
+	barSeries: barChartSchema.omit({
+		type: true,
+		chartType: true,
+		index: true,
+		data: true,
+		title: true,
+		description: true,
+		xAxisLabel: true,
+		showXAxis: true,
+		intervalType: true,
+		startEndOnly: true,
+		showGridLines: true
+	}).extend({ stackType: z$1.enum(["default", "stacked"]).optional().default("default") }),
+	lineSeries: lineChartSchema.omit({
+		type: true,
+		chartType: true,
+		index: true,
+		data: true,
+		title: true,
+		description: true,
+		xAxisLabel: true,
+		showXAxis: true,
+		intervalType: true,
+		startEndOnly: true,
+		showGridLines: true
+	}),
+	startEndOnly: z$1.boolean().optional().default(false),
+	intervalType: z$1.enum(["equidistantPreserveStart", "preserveStartEnd"]).optional().describe("Controls the interval logic of x-axis and how ticks and labels are placed").default("equidistantPreserveStart")
+});
+const predefinedColorScalesSchema = z$1.enum([
+	"Blues",
+	"BrBG",
+	"BuGn",
+	"BuPu",
+	"Cividis",
+	"Cool",
+	"GnBu",
+	"Greens",
+	"Greys",
+	"Inferno",
+	"Magma",
+	"Oranges",
+	"OrRd",
+	"PiYG",
+	"Plasma",
+	"PRGn",
+	"PuBu",
+	"PuBuGn",
+	"PuOr",
+	"PuRd",
+	"Purples",
+	"Rainbow",
+	"RdBu",
+	"RdGy",
+	"RdPu",
+	"RdYlBu",
+	"RdYlGn",
+	"Reds",
+	"Sinebow",
+	"Spectral",
+	"Turbo",
+	"Viridis",
+	"Warm",
+	"YlGn",
+	"YlGnBu",
+	"YlOrBr",
+	"YlOrRd"
+]);
+const interpolateColorScaleSchema = z$1.object({
+	min: chartColor,
+	max: chartColor
+});
+const colorScaleSchema = z$1.union([predefinedColorScalesSchema, interpolateColorScaleSchema]).describe("Type of color scale to use for mapping values to colors");
+const heatmapChartSchema = baseChartSchema.extend({
+	chartType: z$1.literal("heatmap-chart"),
+	data: chartDataSchema,
+	xAxis: z$1.string().describe("key of the data object to map to the x-axis (columns)"),
+	yAxis: z$1.string().array().describe("key(s) of the data object to map to the y-axis (rows) - can be single field or multiple fields"),
+	colorScale: colorScaleSchema.optional().default("Oranges"),
+	xAxisLabel: z$1.string().optional(),
+	yAxisLabel: z$1.string().optional(),
+	showXAxis: z$1.boolean().optional().default(true),
+	showYAxis: z$1.boolean().optional().default(true),
+	showTooltip: z$1.boolean().optional().default(true),
+	showLegend: z$1.boolean().optional().default(true),
+	showValues: z$1.boolean().optional().default(false),
+	valueFormat: valueFormatSchema.optional()
+});
+const chartBlock = z$1.discriminatedUnion("chartType", [
+	areaChartSchema,
+	barChartSchema,
+	comboChartSchema,
+	barListSchema,
+	categoryBarSchema,
+	donutChartSchema,
+	lineChartSchema,
+	progressBarSchema,
+	progressCircleSchema,
+	sparkChartSchema,
+	trackerSchema,
+	heatmapChartSchema
+]);
+const kpiCardChart = z$1.discriminatedUnion("chartType", [
+	categoryBarSchema.omit({
+		title: true,
+		description: true
+	}),
+	progressBarSchema.omit({
+		title: true,
+		description: true
+	}),
+	progressCircleSchema.omit({
+		title: true,
+		description: true
+	}),
+	sparkChartSchema.omit({
+		title: true,
+		description: true
+	}),
+	trackerSchema.omit({
+		title: true,
+		description: true
+	})
+]);
+const kpiCardSchema = z$1.object({
+	type: z$1.literal("kpi-card"),
+	name: z$1.string(),
+	value: z$1.number().or(z$1.string()),
+	valueFormat: valueFormatSchema.optional(),
+	change: z$1.number().or(z$1.string()).optional(),
+	changeType: z$1.enum([
+		"positive",
+		"negative",
+		"neutral"
+	]).optional(),
+	chart: kpiCardChart.optional()
+});
+const tableRenderConfigSchema = z$1.discriminatedUnion("type", [
+	z$1.object({ type: z$1.literal("default") }),
+	z$1.object({
+		type: z$1.literal("badge"),
+		variant: z$1.enum([
+			"default",
+			"neutral",
+			"warning",
+			"error",
+			"success"
+		]).optional().default("default")
+	}),
+	z$1.object({
+		type: z$1.literal("image"),
+		width: z$1.number().optional().default(40),
+		height: z$1.number().optional().default(40),
+		fit: z$1.enum([
+			"cover",
+			"contain",
+			"fill"
+		]).optional().default("cover")
+	}),
+	z$1.object({
+		type: z$1.literal("progress"),
+		chartType: z$1.enum(["bar", "circle"]).optional().default("bar"),
+		maxValue: z$1.number(),
+		variant: z$1.enum([
+			"default",
+			"neutral",
+			"warning",
+			"error",
+			"success"
+		]).optional().default("default")
+	}),
+	z$1.object({
+		type: z$1.literal("link"),
+		target: z$1.enum(["_blank", "_self"]).optional().default("_blank")
+	})
+]);
+const tableColumnSchema = z$1.object({
+	key: z$1.string(),
+	label: z$1.string().optional().describe("display name for the column header"),
+	dataType: z$1.enum([
+		"string",
+		"number",
+		"boolean",
+		"date"
+	]).optional(),
+	sortable: z$1.boolean().optional().default(true),
+	filterable: z$1.boolean().optional().default(true),
+	align: z$1.enum([
+		"left",
+		"center",
+		"right"
+	]).optional().default("left"),
+	valueFormat: valueFormatSchema.optional(),
+	renderConfig: tableRenderConfigSchema.optional().default({ type: "default" }),
+	size: z$1.number().optional(),
+	maxSize: z$1.number().optional()
+});
+const tableBlockSchema = z$1.object({
+	type: z$1.literal("table"),
+	title: z$1.string().optional(),
+	description: z$1.string().optional(),
+	data: z$1.record(z$1.string(), z$1.unknown()).array(),
+	columns: tableColumnSchema.array().optional().describe("column configuration - if not provided, autogenrated from data")
+});
+const imageBlockSchema = z$1.object({
+	type: z$1.literal("image"),
+	url: z$1.string().optional(),
+	buffer: z$1.instanceof(Uint8Array).or(z$1.number().array().transform((val) => new Uint8Array(val))).or(z$1.record(z$1.string(), z$1.number()).transform((val) => {
+		const arr = Array.from({
+			...val,
+			length: Object.keys(val).length
+		});
+		return new Uint8Array(arr);
+	})).or(z$1.string().transform((value) => {
+		const binaryString = atob(value);
+		return Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
+	})).optional(),
+	fit: z$1.enum([
+		"cover",
+		"contain",
+		"fill"
+	]).optional().default("cover"),
+	width: z$1.number().or(z$1.literal("auto")).optional().default(400),
+	height: z$1.number().or(z$1.literal("auto")).optional().default("auto"),
+	aspectRatio: z$1.number().optional(),
+	alt: z$1.string().optional()
+}).refine((value) => value.url || value.buffer, "either url or buffer should be present");
+const textBlockSchema = z$1.object({
+	type: z$1.literal("text"),
+	content: z$1.string()
+});
+const objectBlockSchema = z$1.object({
+	type: z$1.literal("object"),
+	data: dataRecord,
+	title: z$1.string().optional(),
+	description: z$1.string().optional()
+});
+const layoutChildren = z$1.object({
+	get element() {
+		return blockSchema;
+	},
+	colSpan: z$1.number().optional().default(4),
+	rowSpan: z$1.number().optional().default(1)
+});
+const layoutBlockSchema = z$1.object({
+	type: z$1.literal("layout"),
+	columns: z$1.number().optional().default(12),
+	children: layoutChildren.array()
+});
+const blockSchema = z$1.discriminatedUnion("type", [
+	kpiCardSchema,
+	chartBlock,
+	layoutBlockSchema,
+	tableBlockSchema,
+	imageBlockSchema,
+	textBlockSchema,
+	objectBlockSchema
+]);
+const forgeItemSchema = z$1.object({
+	type: z$1.enum([
+		"TOOL",
+		"DIRECTORY",
+		"AGENT"
+	]),
+	id: z$1.string(),
+	name: z$1.string(),
+	description: z$1.string().optional(),
+	parent: z$1.string().optional(),
+	depth: z$1.number()
+});
+const baseFormField = z$1.object({
+	label: z$1.string(),
+	description: z$1.string().optional(),
+	optional: z$1.boolean().optional()
+});
+const textInputField = baseFormField.extend({
+	type: z$1.literal("text"),
+	secure: z$1.boolean().optional(),
+	mode: z$1.enum(["input", "textarea"]).optional(),
+	inputType: z$1.enum(["email", "url"]).optional(),
+	min: z$1.number().optional(),
+	max: z$1.number().optional()
+});
+const numberInputField = baseFormField.extend({
+	type: z$1.literal("number"),
+	min: z$1.number().optional(),
+	max: z$1.number().optional()
+});
+const dateInputField = baseFormField.extend({
+	type: z$1.literal("date"),
+	min: z$1.iso.datetime().optional(),
+	max: z$1.iso.datetime().optional(),
+	mode: z$1.enum([
+		"single",
+		"multiple",
+		"range"
+	]).optional()
+});
+const selectOptionValue = z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean()
+]);
+const selectOption = z$1.object({
+	label: z$1.string(),
+	description: z$1.string().optional(),
+	value: selectOptionValue
+});
+const selectInputField = baseFormField.extend({
+	type: z$1.literal("select"),
+	options: selectOption.array().min(1, "atleast one option should be present").readonly(),
+	mode: z$1.enum([
+		"select",
+		"multi-select",
+		"checkbox",
+		"multi-checkbox",
+		"radio",
+		"radio-card"
+	]).optional()
+});
+const tableInputField = baseFormField.extend({
+	type: z$1.literal("table"),
+	data: dataRecord.array().readonly(),
+	mode: z$1.enum(["multiple", "single"]).optional(),
+	min: z$1.number().optional(),
+	max: z$1.number().optional()
+});
+const searchInputField = baseFormField.extend({
+	type: z$1.literal("search"),
+	mode: z$1.enum(["multiple", "single"]).optional(),
+	min: z$1.number().optional(),
+	max: z$1.number().optional()
+});
+const uploadInputField = baseFormField.extend({
+	type: z$1.literal("upload"),
+	mode: z$1.enum(["single", "multiple"]).optional(),
+	accept: z$1.record(z$1.string().describe("mimeType supported"), z$1.string().array().describe("array of file extensions")).optional()
+});
+const uploadedFileSchema = z$1.object({
+	type: z$1.string().optional(),
+	name: z$1.string().optional(),
+	buffer: z$1.instanceof(Uint8Array).or(z$1.number().array().transform((val) => new Uint8Array(val))).or(z$1.record(z$1.string(), z$1.number()).transform((val) => {
+		const arr = Array.from({
+			...val,
+			length: Object.keys(val).length
+		});
+		return new Uint8Array(arr);
+	})).or(z$1.instanceof(ArrayBuffer)),
+	size: z$1.number()
+});
+const formInputField = z$1.discriminatedUnion("type", [
+	textInputField,
+	numberInputField,
+	dateInputField,
+	selectInputField,
+	tableInputField,
+	searchInputField,
+	uploadInputField
+]);
+const ioForm = z$1.record(z$1.string(), formInputField);
+function getValidationSchemaForField(field) {
+	let schema = match(field).returnType().with({ type: "text" }, ({ inputType, min, max }) => {
+		let stringSchema = match(inputType).with("email", () => z$1.email()).with("url", () => z$1.url()).otherwise(() => z$1.string());
+		if (typeof min === "number") stringSchema = stringSchema.min(min, `input should be at least ${min} characters`);
+		if (typeof max === "number") stringSchema = stringSchema.max(max, `input should be at most ${max} characters`);
+		return stringSchema;
+	}).with({ type: "number" }, ({ min, max }) => {
+		let schema$1 = z$1.number();
+		if (typeof min == "number") schema$1 = schema$1.min(min);
+		if (typeof max === "number") schema$1 = schema$1.max(max);
+		return schema$1;
+	}).with({ type: "date" }, ({ min, max, mode }) => {
+		const baseSchema = (() => {
+			let schema$1 = z$1.iso.datetime();
+			if (z$1.iso.datetime().safeParse(min).success) schema$1 = schema$1.refine((value) => (0, import_dayjs_min.default)(value).isAfter((0, import_dayjs_min.default)(min)), `date should be after ${(0, import_dayjs_min.default)(min).format("DD MMM YYYY")}`);
+			if (z$1.iso.datetime().safeParse(max).success) schema$1 = schema$1.refine((value) => (0, import_dayjs_min.default)(value).isBefore((0, import_dayjs_min.default)(max)), `date should be before ${(0, import_dayjs_min.default)(max).format("DD MMM YYYY")}`);
+			return schema$1;
+		})();
+		return match(mode).returnType().with(P.union("single", void 0), () => baseSchema).with("multiple", () => baseSchema.array()).with("range", () => z$1.object({
+			from: baseSchema,
+			to: baseSchema
+		})).exhaustive();
+	}).with({ type: "select" }, ({ options, mode }) => {
+		let schema$1 = z$1.enum(options.map((option) => option.value));
+		if (mode === "multi-checkbox" || mode === "multi-select") schema$1 = schema$1.array();
+		return schema$1;
+	}).with({ type: "table" }, ({ data, mode, min, max }) => {
+		let schema$1 = z$1.unknown().refine((value) => {
+			return !!data.find((item) => deepEqual(item, value));
+		}, "value of should be one of the item in the array");
+		if (mode === "multiple") {
+			schema$1 = schema$1.array();
+			if (typeof min === "number") schema$1 = schema$1.min(min);
+			if (typeof max === "number") schema$1 = schema$1.max(max);
+		}
+		return schema$1;
+	}).with({ type: "search" }, ({ mode, min, max }) => {
+		let schema$1 = z$1.string();
+		if (mode === "multiple") {
+			schema$1 = schema$1.array();
+			if (typeof min === "number") schema$1 = schema$1.min(min);
+			if (typeof max === "number") schema$1 = schema$1.max(max);
+		}
+		return schema$1;
+	}).with({ type: "upload" }, ({ mode }) => {
+		let schema$1 = uploadedFileSchema;
+		if (mode === "multiple") schema$1 = schema$1.array();
+		return schema$1;
+	}).exhaustive();
+	if (field.optional) schema = schema.optional();
+	return schema;
+}
+function getValidationSchemaForForm(schema) {
+	let validationSchema = z$1.object({});
+	for (const [key, value] of Object.entries(schema)) {
+		const schema$1 = getValidationSchemaForField(value);
+		validationSchema = validationSchema.extend({ [key]: schema$1 });
+	}
+	return validationSchema;
+}
+const confirm = z$1.object({
+	title: z$1.string(),
+	description: z$1.string().optional(),
+	block: blockSchema.optional(),
+	okButtonLabel: z$1.string().optional().default("OK"),
+	cancelButtonLabel: z$1.string().optional().default("Cancel")
+});
+const baseMessageSchema = z$1.object({
+	id: z$1.nanoid(),
+	timestamp: z$1.number().min(0, { message: "timestamp must be a positive number" })
+});
+const runnerId = z$1.string().regex(/^tf-runner:[A-Za-z0-9_-]{32}$/, { message: "runnerId must start with \"tf-runner:\" followed by a 32-character nanoid" });
+const clientId = z$1.string().regex(/^tf-client:[A-Za-z0-9_-]{32}$/, { message: "runnerId must start with \"tf-runner:\" followed by a 32-character nanoid" });
+const sdkServerId = z$1.string().regex(/^tf-ss:[A-Za-z0-9_-]{32}$/, { message: "serverId must start with \"tf-ss:\" followed by a 32-character nanoid" });
+const appServerId = z$1.string().regex(/^tf-as:[A-Za-z0-9_-]{32}$/, { message: "serverId must start with \"tf-ss:\" followed by a 32-character nanoid" });
+const serverId = z$1.union([sdkServerId, appServerId]);
+const ackMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("ACK"),
+	rootMessageId: z$1.string(),
+	data: z$1.discriminatedUnion("type", [z$1.object({ type: z$1.literal("SUCCESS") }), z$1.object({
+		type: z$1.literal("ERROR"),
+		error: z$1.string()
+	})])
+});
+const initCommunicationMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("INIT_COMMUNICATION"),
+	data: z$1.object({
+		serverId,
+		heartbeatIntervalMs: z$1.number().min(1e3, { message: "heartbeatInterval must be at least 1000ms" }),
+		heartbeatAckTimeoutMs: z$1.number().min(1e3, { message: "heartbeatAckTimeout must be at least 1000ms" }),
+		maxRetries: z$1.number().min(0, { message: "maxRetries must be at least 0" })
+	})
+});
+const heartbeatMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("HEARTBEAT"),
+	data: z$1.discriminatedUnion("clientType", [z$1.object({
+		clientType: z$1.literal("RUNNER"),
+		runnerId,
+		cpuUsage: z$1.number(),
+		memoryUsage: z$1.number(),
+		activeSessionsCount: z$1.number()
+	}), z$1.object({
+		clientType: z$1.literal("CLIENT"),
+		clientId
+	})])
+});
+const heartbeatAckMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("HEARTBEAT_ACK"),
+	data: z$1.discriminatedUnion("clientType", [z$1.object({
+		clientType: z$1.literal("RUNNER"),
+		runnerId,
+		serverId: sdkServerId
+	}), z$1.object({
+		clientType: z$1.literal("CLIENT"),
+		clientId,
+		serverId: appServerId
+	})])
+});
+const listForgeMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("LIST_FORGE"),
+	data: z$1.object({
+		runnerId,
+		forgeItems: forgeItemSchema.array()
+	})
+});
+const reloadForgeMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("RELOAD_FORGE"),
+	data: z$1.object({ environmentId: z$1.uuid() })
+});
+const startToolMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("START_TOOL"),
+	data: z$1.object({
+		toolId: z$1.string(),
+		itemId: z$1.string(),
+		sessionId: z$1.uuid(),
+		environmentId: z$1.uuid()
+	})
+});
+const stopToolMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STOP_TOOL"),
+	data: z$1.object({ sessionId: z$1.uuid() })
+});
+const executionContextSchema = z$1.discriminatedUnion("type", [
+	z$1.object({ type: z$1.literal("TOOL") }),
+	z$1.object({
+		type: z$1.literal("STEP"),
+		id: z$1.nanoid(),
+		step: z$1.object({
+			name: z$1.string(),
+			description: z$1.string().optional()
+		})
+	}),
+	z$1.object({ type: z$1.literal("AGENT") })
+]);
+const renderInputsMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("RENDER_INPUTS"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		form: ioForm,
+		defaultValues: z$1.record(z$1.string(), z$1.unknown()).optional(),
+		title: z$1.string().optional(),
+		description: z$1.string().optional(),
+		executionContext: executionContextSchema
+	})
+});
+const inputsResponseMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("INPUTS_RESPONSE"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		inputs: z$1.record(z$1.string(), z$1.unknown()),
+		executionContext: executionContextSchema
+	})
+});
+const inputsValidMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("INPUTS_VALID"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		runnerId,
+		sessionId: z$1.uuid(),
+		executionContext: executionContextSchema
+	})
+});
+const inputsErrorMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("INPUTS_ERROR"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		issues: z$1.object({
+			code: z$1.string(),
+			message: z$1.string(),
+			path: z$1.union([
+				z$1.string(),
+				z$1.number(),
+				z$1.symbol()
+			]).array()
+		}).array(),
+		attemptsRemaining: z$1.number(),
+		executionContext: executionContextSchema
+	})
+});
+const searchInputMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("SEARCH_INPUT"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		searchInputId: z$1.string(),
+		query: z$1.string().min(1, { message: "query must be at least 1 character" }),
+		executionContext: executionContextSchema
+	})
+});
+const searchInputResponseMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("SEARCH_INPUT_RESPONSE"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		searchInputId: z$1.string(),
+		results: selectOption.array(),
+		executionContext: executionContextSchema
+	})
+});
+const searchInputErrorMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("SEARCH_INPUT_ERROR"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		searchInputId: z$1.string(),
+		error: z$1.object({
+			message: z$1.string(),
+			code: z$1.string().optional(),
+			details: z$1.record(z$1.string(), z$1.unknown()).optional(),
+			stack: z$1.string().optional()
+		}),
+		executionContext: executionContextSchema
+	})
+});
+const toolCompleteMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("TOOL_COMPLETE"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		output: z$1.unknown(),
+		executionContext: executionContextSchema
+	})
+});
+const toolErrorMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("TOOL_ERROR"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		error: z$1.object({
+			message: z$1.string(),
+			code: z$1.string().optional(),
+			details: z$1.record(z$1.string(), z$1.unknown()).optional(),
+			stack: z$1.string().optional()
+		}),
+		executionContext: executionContextSchema
+	})
+});
+const listenForEnvironmentChangesMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("LISTEN_FOR_ENVIRONMENT_CHANGES"),
+	data: z$1.object({
+		environmentId: z$1.uuid(),
+		clientId
+	})
+});
+const listenForForgeSessionMessagesMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("LISTEN_FOR_FORGE_SESSION_MESSAGES"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		clientId
+	})
+});
+const startLoaderMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("START_LOADER"),
+	data: z$1.object({
+		sessionId: z$1.string(),
+		title: z$1.string(),
+		description: z$1.string().optional(),
+		executionContext: executionContextSchema
+	})
+});
+const stopLoaderMessgeSchema = baseMessageSchema.extend({
+	type: z$1.literal("STOP_LOADER"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.string(),
+		executionContext: executionContextSchema
+	})
+});
+const startProgressLoaderMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("START_PROGRESS_LOADER"),
+	data: z$1.object({
+		sessionId: z$1.string(),
+		itemsInQueue: z$1.number(),
+		title: z$1.string(),
+		description: z$1.string().optional(),
+		executionContext: executionContextSchema
+	})
+});
+const updateProgressLoaderMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("UPDATE_PROGRESS_LOADER"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.string(),
+		itemsCompleted: z$1.number(),
+		executionContext: executionContextSchema
+	})
+});
+const stopProgressLoaderMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STOP_PROGRESS_LOADER"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.string(),
+		executionContext: executionContextSchema
+	})
+});
+const confirmMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("CONFIRM"),
+	data: confirm.extend({
+		runnerId,
+		sessionId: z$1.uuid(),
+		executionContext: executionContextSchema
+	})
+});
+const confirmResponseMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("CONFIRM_RESPONSE"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		confirmed: z$1.boolean(),
+		executionContext: executionContextSchema
+	})
+});
+const confirmValidMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("CONFIRM_VALID"),
+	rootMessageId: z$1.string(),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		executionContext: executionContextSchema
+	})
+});
+const showMessageMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("SHOW_MESSAGE"),
+	data: z$1.object({
+		title: z$1.string().optional(),
+		description: z$1.string().optional(),
+		message: z$1.union([
+			primitiveSchema,
+			dataRecord,
+			dataRecord.array(),
+			blockSchema
+		]),
+		sessionId: z$1.string(),
+		executionContext: executionContextSchema
+	})
+});
+const startAgentMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("START_AGENT"),
+	data: z$1.object({
+		agentId: z$1.string(),
+		itemId: z$1.string(),
+		sessionId: z$1.uuid(),
+		environmentId: z$1.uuid()
+	})
+});
+const stopAgentMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STOP_AGENT"),
+	data: z$1.object({ sessionId: z$1.uuid() })
+});
+const stepStartMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STEP_START"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		executionContext: executionContextSchema
+	})
+});
+const stepCompleteMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STEP_COMPLETE"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		output: z$1.unknown().optional(),
+		executionContext: executionContextSchema
+	})
+});
+const stepErrorMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("STEP_ERROR"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		error: z$1.object({
+			message: z$1.string(),
+			code: z$1.string().optional(),
+			details: z$1.record(z$1.string(), z$1.unknown()).optional(),
+			stack: z$1.string().optional()
+		}),
+		executionContext: executionContextSchema
+	})
+});
+const agentStartMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("AGENT_START"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		agentWorkflow: agentWorkflowSchema,
+		executionContext: executionContextSchema
+	})
+});
+const agentCompleteMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("AGENT_COMPLETE"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		output: z$1.unknown(),
+		executionContext: executionContextSchema
+	})
+});
+const agentErrorMessageSchema = baseMessageSchema.extend({
+	type: z$1.literal("AGENT_ERROR"),
+	data: z$1.object({
+		sessionId: z$1.uuid(),
+		error: z$1.object({
+			message: z$1.string(),
+			code: z$1.string().optional(),
+			details: z$1.record(z$1.string(), z$1.unknown()).optional(),
+			stack: z$1.string().optional()
+		}),
+		executionContext: executionContextSchema
+	})
+});
+
+//#endregion
+//#region src/internal/block.ts
+var Block = class {
+	#signal;
+	constructor(options) {
+		this.#signal = options.signal;
+	}
+	/**
+	* Creates an area chart block.
+	*/
+	areaChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return areaChartSchema.parse({
+			type: "chart",
+			chartType: "area-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a bar chart block.
+	*/
+	barChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return barChartSchema.parse({
+			type: "chart",
+			chartType: "bar-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a bar list block.
+	*
+	* A bar list is a vertical list of horizontal bars, useful for comparing multiple values.
+	*/
+	barList(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return barListSchema.parse({
+			type: "chart",
+			chartType: "bar-list",
+			...props
+		});
+	}
+	/**
+	* Creates a category bar block.
+	*
+	* A category bar is a horizontal bar chart that displays categorical data.
+	*/
+	categoryBar(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return categoryBarSchema.parse({
+			type: "chart",
+			chartType: "category-bar",
+			...props
+		});
+	}
+	/**
+	* Creates a donut chart block.
+	*/
+	donutChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return donutChartSchema.parse({
+			type: "chart",
+			chartType: "donut-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a line chart block.
+	*/
+	lineChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return lineChartSchema.parse({
+			type: "chart",
+			chartType: "line-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a progress bar block.
+	*
+	* A progress bar is a visual representation of progress towards a goal.
+	*/
+	progressBar(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return progressBarSchema.parse({
+			type: "chart",
+			chartType: "progress-bar",
+			...props
+		});
+	}
+	/**
+	* Creates a progress circle block.
+	*
+	* A progress circle is a circular representation of progress towards a goal.
+	*/
+	progressCircle(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return progressCircleSchema.parse({
+			type: "chart",
+			chartType: "progress-circle",
+			...props
+		});
+	}
+	/**
+	* Creates a spark chart block.
+	*
+	* A spark chart is a small, simple chart that provides a visual representation of data trends.
+	*/
+	sparkChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return sparkChartSchema.parse({
+			type: "chart",
+			chartType: "spark-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a tracker block.
+	*
+	* A tracker chart is a visual display that shows the real-time or historical status of multiple systems, services, or metrics in a consolidated view, typically using color-coded indicators (green, yellow, red) to quickly communicate operational health.
+	*/
+	tracker(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return trackerSchema.parse({
+			type: "chart",
+			chartType: "tracker",
+			...props
+		});
+	}
+	/**
+	* Creates a combo chart block.
+	*
+	* A combo chart combines multiple chart types (e.g., bar and line) into a single visualization to represent different data series.
+	*/
+	comboChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return comboChartSchema.parse({
+			type: "chart",
+			chartType: "combo-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a heatmap chart block.
+	*
+	* A heatmap chart is a graphical representation of data where individual values are represented as colors in a matrix, allowing for quick identification of patterns, correlations, and outliers within large datasets.
+	*/
+	heatmapChart(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return heatmapChartSchema.parse({
+			type: "chart",
+			chartType: "heatmap-chart",
+			...props
+		});
+	}
+	/**
+	* Creates a KPI card block.
+	*
+	* A KPI (Key Performance Indicator) card is a visual representation of a specific metric or performance indicator, typically displayed in a concise format to provide quick insights into business performance.
+	* It often includes elements such as the current value, target value, percentage change, and visual cues (like colors or icons) to indicate performance status.
+	* It can include charts such as sparklines or progress indicators to provide additional context.
+	*/
+	kpiCard(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return kpiCardSchema.parse({
+			type: "kpi-card",
+			...props
+		});
+	}
+	/**
+	* Creates a table block.
+	*
+	* A table block displays data in a structured tabular format, allowing for easy comparison and analysis of information across rows and columns.
+	* It can include features such as sorting, filtering, and pagination to enhance data exploration.
+	* You can also include charts within table cells for visual representation of data, by providing appropriate render configuration.
+	*/
+	table(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return tableBlockSchema.parse({
+			type: "table",
+			...props
+		});
+	}
+	/**
+	* Creates an image block.
+	*
+	* An image block displays an image from a given URL with optional alt text and caption.
+	*/
+	image(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return imageBlockSchema.parse({
+			type: "image",
+			...props
+		});
+	}
+	/**
+	* Creates a text block.
+	*
+	* A text block displays formatted text content, supporting markdown syntax for styling.
+	*/
+	text(props) {
+		if (this.#signal.aborted) throw new Error("tool execution aborted");
+		return textBlockSchema.parse({
+			type: "text",
+			...props
+		});
+	}
+	/**
+	* Creates an object block.
+	*
+	* An object block allows for rendering structured data. Data would be rendered as a key-value pairs.
+	*/
+	object(props) {
+		return objectBlockSchema.parse({
+			type: "object",
+			...props
+		});
+	}
+	/**
+	* Creates a layout block.
+	*
+	* A layout block is used to arrange other blocks in a grid layout.
+	*/
+	layout(props) {
+		return layoutBlockSchema.parse({
+			type: "layout",
+			...props
+		});
+	}
+};
+
+//#endregion
+//#region ../core/dist/utils.js
+function exponentialBackoff(attempt, initialDelay = 1e3, maxRetryDelay = 3e4, jitterFactor = .5, backoffMultiplier = 2) {
+	let delay = initialDelay * Math.pow(backoffMultiplier, attempt - 1);
+	const jitter = delay * jitterFactor * Math.random();
+	delay += jitter;
+	return Math.min(delay, maxRetryDelay);
+}
+function runWithRetries(fn, retries = 3, config = {}) {
+	let attempt = 0;
+	const execute = async () => {
+		try {
+			return await fn();
+		} catch (error) {
+			if (attempt < retries) {
+				attempt++;
+				await setTimeout(exponentialBackoff(attempt, config.initialDelayMs, config.maxDelayMs, config.backoffMultiplier));
+				return execute();
+			}
+			throw error;
+		}
+	};
+	return execute();
+}
+
+//#endregion
+//#region src/lib/utils.ts
+function convertToWords(input) {
+	if (input.includes("-") || input.includes("_")) return input.split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+	return input.split(/(?=[A-Z])/).filter((word) => word.length > 0).map((word) => word.toLowerCase());
+}
+function invariant(cond, message) {
+	if (!cond) throw new Error(message);
+}
+function getErrorMessage(error, defaultMessage = "Something went wrong. Please try again") {
+	let errorMessage = defaultMessage;
+	if (error instanceof z$1.ZodError) errorMessage = error.issues.length ? error.issues.map((e) => e.message).join(", ") : error.message;
+	else if (error instanceof Error) errorMessage = error.message;
+	return errorMessage;
+}
+
+//#endregion
+//#region src/internal/loader.ts
+var Loader = class {
+	#id = nanoid();
+	#sessionId;
+	#executionContext;
+	#title;
+	#description;
+	#webSocketClient;
+	#signal;
+	constructor(options) {
+		this.#sessionId = options.sessionId;
+		this.#executionContext = options.executionContext;
+		this.#title = options.title;
+		this.#description = options.description;
+		this.#webSocketClient = options.webSocketClient;
+		this.#signal = options.signal;
+	}
+	async start() {
+		if (this.#signal.aborted) return this;
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: this.#id,
+			type: "START_LOADER",
+			timestamp: Date.now(),
+			data: {
+				sessionId: this.#sessionId,
+				title: this.#title,
+				description: this.#description,
+				executionContext: this.#executionContext
+			}
+		}));
+		return this;
+	}
+	async stop() {
+		if (this.#signal.aborted) return this;
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: nanoid(),
+			timestamp: Date.now(),
+			type: "STOP_LOADER",
+			rootMessageId: this.#id,
+			data: {
+				sessionId: this.#sessionId,
+				executionContext: this.#executionContext
+			}
+		}));
+		return this;
+	}
+};
+
+//#endregion
+//#region src/internal/progress-loader.ts
+var ProgressLoader = class {
+	#id = nanoid();
+	#title;
+	#description;
+	#itemsCompleted = 0;
+	#itemsInQueue;
+	#sessionId;
+	#executionContext;
+	#webSocketClient;
+	#signal;
+	constructor(options) {
+		this.#title = options.title;
+		this.#description = options.description;
+		this.#itemsInQueue = options.itemsInQueue;
+		this.#sessionId = options.sessionId;
+		this.#executionContext = options.executionContext;
+		this.#webSocketClient = options.webSocketClient;
+		this.#signal = options.signal;
+	}
+	/** Starts the progress loader. */
+	async start() {
+		if (this.#signal.aborted) return this;
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: this.#id,
+			type: "START_PROGRESS_LOADER",
+			timestamp: Date.now(),
+			data: {
+				sessionId: this.#sessionId,
+				itemsInQueue: this.#itemsInQueue,
+				title: this.#title,
+				description: this.#description,
+				executionContext: this.#executionContext
+			}
+		}));
+		return this;
+	}
+	/**
+	* Updates the progress loader with the number of items completed.
+	*/
+	async update(itemsCompleted) {
+		if (this.#signal.aborted) return this;
+		this.#itemsCompleted = itemsCompleted;
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: nanoid(),
+			type: "UPDATE_PROGRESS_LOADER",
+			timestamp: Date.now(),
+			rootMessageId: this.#id,
+			data: {
+				sessionId: this.#sessionId,
+				itemsCompleted: this.#itemsCompleted,
+				executionContext: this.#executionContext
+			}
+		}));
+		return this;
+	}
+	/**
+	* Increments the number of items completed by one and updates the progress loader.
+	*/
+	async increment() {
+		if (this.#signal.aborted) return this;
+		this.#itemsCompleted += 1;
+		return this.update(this.#itemsCompleted);
+	}
+	/** Stops the progress loader. */
+	async stop() {
+		if (this.#signal.aborted) return this;
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: nanoid(),
+			timestamp: Date.now(),
+			type: "STOP_PROGRESS_LOADER",
+			rootMessageId: this.#id,
+			data: {
+				sessionId: this.#sessionId,
+				executionContext: this.#executionContext
+			}
+		}));
+		return this;
+	}
+};
+
+//#endregion
+//#region src/internal/io.ts
+const STOP_SYMBOL = Symbol("IO_STOP_SYMBOL");
+const toIOMessageSchema = z$1.discriminatedUnion("type", [
+	inputsResponseMessageSchema,
+	searchInputMessageSchema,
+	confirmResponseMessageSchema
+]);
+var IO = class {
+	#sessionId;
+	#runnerId;
+	#executionContext;
+	#signal;
+	#webSocketClient;
+	#unsubscribeMessageHandler;
+	#logger;
+	/**
+	* map of pending IOs to their corresponding resolve functions.
+	* it is used to track which IO is waiting for a user input.
+	*/
+	#pendingIOs = /* @__PURE__ */ new Map();
+	constructor(options, logger) {
+		this.#sessionId = options.sessionId;
+		this.#runnerId = options.runnerId;
+		this.#executionContext = options.executionContext;
+		this.#logger = logger.child({
+			sessionId: this.#sessionId,
+			component: "IO"
+		});
+		this.#signal = options.signal;
+		this.#webSocketClient = options.webSocketClient;
+		this.#unsubscribeMessageHandler = this.#webSocketClient.subscribeToMessages(this.#handleWebSocketMessage.bind(this));
+		this.#signal.addEventListener("abort", this.#stop.bind(this));
+	}
+	/**
+	* Handles messages received from the worker.
+	*/
+	async #handleWebSocketMessage(message) {
+		const ioMessageParsed = toIOMessageSchema.safeParse(message);
+		if (ioMessageParsed.success && ioMessageParsed.data.data.sessionId === this.#sessionId) {
+			const message$1 = ioMessageParsed.data;
+			try {
+				await this.#handleIOResponseMessage(message$1);
+			} catch (error) {
+				this.#logger.error(error, "error handling IO message of type %s from worker", ioMessageParsed.data.type);
+				throw error;
+			}
+		}
+	}
+	#handleIOResponseMessage(message) {
+		this.#logger.debug({ data: message }, "handling inputs response message from worker");
+		const pendingIO = this.#pendingIOs.get(message.rootMessageId);
+		if (!pendingIO) {
+			this.#logger.warn("received inputs response for unknown message id %s", message.rootMessageId);
+			return;
+		}
+		pendingIO(message);
+	}
+	[STOP_SYMBOL]() {
+		this.#stop();
+	}
+	#stop() {
+		this.#logger.debug("stopping IO...");
+		if (this.#unsubscribeMessageHandler) {
+			this.#logger.debug("unsubscribing from message handler");
+			this.#unsubscribeMessageHandler();
+			this.#unsubscribeMessageHandler = void 0;
+		}
+		this.#pendingIOs.clear();
+		this.#logger.debug("IO stopped");
+	}
+	#formInput({ form, title, description, validationSchema, maxRetryAttempts, defaultValues }) {
+		return new Promise(async (resolve, reject) => {
+			if (this.#signal.aborted) {
+				this.#logger.warn("form input aborted before start");
+				return reject(/* @__PURE__ */ new Error("form input aborted"));
+			}
+			const messageId = nanoid();
+			let attempts = 0;
+			const searchHandlers = {};
+			const sanitizedForm = Object.entries(form).reduce((acc, [key, value]) => {
+				if (value.type === "search") {
+					const { handleSearch,...rest } = value;
+					if (handleSearch && typeof handleSearch === "function") searchHandlers[key] = handleSearch;
+					return {
+						...acc,
+						[key]: rest
+					};
+				}
+				return {
+					...acc,
+					[key]: value
+				};
+			}, {});
+			this.#signal.addEventListener("abort", () => {
+				this.#logger.warn("form input aborted");
+				this.#pendingIOs.delete(messageId);
+				reject(/* @__PURE__ */ new Error("form input aborted"));
+			});
+			const resolveIO = async (message) => {
+				if (message.type === "SEARCH_INPUT") {
+					const searchHandler = searchHandlers[message.data.searchInputId];
+					if (typeof searchHandler !== "function") {
+						this.#logger.error("no search handler found for search input id %s", message.data.searchInputId);
+						reject(/* @__PURE__ */ new Error(`no search handler found for search input id ${message.data.searchInputId}`));
+						return;
+					}
+					try {
+						const results = await searchHandler(message.data.query);
+						await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+							id: nanoid(),
+							timestamp: Date.now(),
+							rootMessageId: message.id,
+							type: "SEARCH_INPUT_RESPONSE",
+							data: {
+								sessionId: this.#sessionId,
+								searchInputId: message.data.searchInputId,
+								results,
+								executionContext: this.#executionContext
+							}
+						}));
+						this.#logger.debug({
+							messageId,
+							resultsCount: results.length
+						}, "executed search handler for search input id %s", message.data.searchInputId);
+					} catch (error) {
+						this.#logger.error(error, "error executing search handler for search input id %s", message.data.searchInputId);
+						await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+							id: nanoid(),
+							timestamp: Date.now(),
+							rootMessageId: message.id,
+							type: "SEARCH_INPUT_ERROR",
+							data: {
+								sessionId: this.#sessionId,
+								searchInputId: message.data.searchInputId,
+								error: { message: getErrorMessage(error) },
+								executionContext: this.#executionContext
+							}
+						}));
+					}
+				} else if (message.type === "INPUTS_RESPONSE") {
+					this.#pendingIOs.delete(messageId);
+					const value = message.data.inputs;
+					const parsed = validationSchema.safeParse(value);
+					if (parsed.success) {
+						try {
+							this.#logger.debug({
+								messageId,
+								input: parsed.data
+							}, "received valid input from user");
+							resolve(parsed.data);
+							await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+								id: nanoid(),
+								timestamp: Date.now(),
+								rootMessageId: messageId,
+								type: "INPUTS_VALID",
+								data: {
+									runnerId: this.#runnerId,
+									sessionId: this.#sessionId,
+									executionContext: this.#executionContext
+								}
+							}));
+						} catch (error) {
+							this.#logger.error(error, "error sending INPUTS_VALID message to worker");
+							reject(error);
+						}
+						return;
+					}
+					attempts += 1;
+					await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+						id: nanoid(),
+						timestamp: Date.now(),
+						rootMessageId: messageId,
+						type: "INPUTS_ERROR",
+						data: {
+							sessionId: this.#sessionId,
+							issues: parsed.error.issues,
+							attemptsRemaining: maxRetryAttempts - attempts,
+							executionContext: this.#executionContext
+						}
+					}));
+					if (attempts >= maxRetryAttempts) {
+						this.#logger.error("maximum attempts reached for input %s", messageId);
+						return reject(/* @__PURE__ */ new Error(`maximum attempts reached for input ${messageId}`));
+					}
+					this.#logger.warn("invalid input %s for %s", parsed.error, messageId);
+					this.#pendingIOs.set(messageId, resolveIO);
+					this.#logger.debug({ messageId }, "waiting for user to provide valid input");
+				}
+			};
+			this.#pendingIOs.set(messageId, resolveIO);
+			this.#logger.debug({ messageId }, "setup pending IO for form input");
+			await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+				id: messageId,
+				timestamp: Date.now(),
+				type: "RENDER_INPUTS",
+				data: {
+					sessionId: this.#sessionId,
+					form: sanitizedForm,
+					title,
+					description,
+					executionContext: this.#executionContext,
+					defaultValues
+				}
+			}));
+		});
+	}
+	/**
+	* Prompts the user for a text input.
+	*/
+	async textInput({ label, description, optional, secure, inputType, mode, maxRetryAttempts = 5, validationSchema, defaultValue }) {
+		const form = { value: {
+			type: "text",
+			label,
+			description,
+			optional,
+			secure,
+			mode,
+			inputType
+		} };
+		const stringValidationSchema = validationSchema ?? getValidationSchemaForField(form.value);
+		const formValidationSchema = z$1.object({ value: stringValidationSchema });
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts,
+			defaultValues: { value: defaultValue }
+		})).value;
+	}
+	/**
+	* Prompts the user for a number input.
+	*/
+	async numberInput({ label, description, optional, min, max, maxRetryAttempts = 5, validationSchema, defaultValue }) {
+		const form = { value: {
+			type: "number",
+			min,
+			max,
+			optional,
+			label,
+			description
+		} };
+		const numberValidationSchema = validationSchema ?? getValidationSchemaForField(form.value);
+		const formValidationSchema = z$1.object({ value: numberValidationSchema });
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts,
+			defaultValues: { value: defaultValue }
+		})).value;
+	}
+	/**
+	* Prompts the user for a date input. It can be single date, multiple dates or a date range.
+	*/
+	async dateInput({ label, description, optional, min, max, mode = "single", maxRetryAttempts = 5, validationSchema, defaultValue }) {
+		const form = { value: {
+			type: "date",
+			min,
+			max,
+			mode,
+			optional,
+			label,
+			description
+		} };
+		const dateValidationSchema = validationSchema ?? getValidationSchemaForField(form.value);
+		const formValidationSchema = z$1.object({ value: dateValidationSchema });
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts,
+			defaultValues: { value: defaultValue }
+		})).value;
+	}
+	/**
+	* Prompts the user for a select input. It can be single select or multi select
+	*/
+	async selectInput({ label, description, optional, options, mode = "select", maxRetryAttempts = 5, defaultValue }) {
+		const form = { value: {
+			type: "select",
+			label,
+			description,
+			options,
+			mode,
+			optional
+		} };
+		const formValidationSchema = getValidationSchemaForForm(form);
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts,
+			defaultValues: { value: defaultValue }
+		})).value;
+	}
+	async tableInput({ label, description, data, max, min, mode = "single", optional, defaultValue }) {
+		const form = { value: {
+			type: "table",
+			label,
+			description,
+			data,
+			max,
+			min,
+			mode,
+			optional
+		} };
+		const formValidationSchema = getValidationSchemaForForm(form);
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts: 1,
+			defaultValues: { value: defaultValue }
+		})).value;
+	}
+	/**
+	* Prompts the user for a search input. It can be single search or multi search.
+	*/
+	async searchInput({ label, description, mode = "single", optional, min, max, handleSearch }) {
+		const form = { value: {
+			type: "search",
+			label,
+			description,
+			mode,
+			optional,
+			min,
+			max,
+			handleSearch
+		} };
+		const formValidationSchema = getValidationSchemaForForm(form);
+		return (await this.#formInput({
+			form,
+			validationSchema: formValidationSchema,
+			maxRetryAttempts: 1
+		})).value;
+	}
+	/**
+	* Prompts the user for a form input.
+	*/
+	async formInput({ form, validationSchema, maxRetryAttempts = 5, title, description, defaultValues }) {
+		const schema = validationSchema ?? getValidationSchemaForForm(form);
+		return await this.#formInput({
+			form,
+			validationSchema: schema,
+			maxRetryAttempts,
+			title,
+			description,
+			defaultValues
+		});
+	}
+	/**
+	* Creates a loader instance to show loading state to the user.
+	*/
+	loader({ title, description }) {
+		return new Loader({
+			title,
+			description,
+			sessionId: this.#sessionId,
+			webSocketClient: this.#webSocketClient,
+			signal: this.#signal,
+			executionContext: this.#executionContext
+		});
+	}
+	/**
+	* Creates a progress loader instance to show progress of a long-running operation to the user.
+	* It can be used to indicate that a process is ongoing and provide feedback on its status.
+	*/
+	progressLoader({ title, description, itemsInQueue }) {
+		return new ProgressLoader({
+			title,
+			description,
+			itemsInQueue,
+			webSocketClient: this.#webSocketClient,
+			sessionId: this.#sessionId,
+			signal: this.#signal,
+			executionContext: this.#executionContext
+		});
+	}
+	/**
+	* Prompts the user for a confirmation (OK/Cancel).
+	* Returns true if the user clicked OK, false if Cancel.
+	*/
+	async confirm({ title, description, okButtonLabel = "OK", cancelButtonLabel = "Cancel", block }) {
+		const message = {
+			id: nanoid(),
+			timestamp: Date.now(),
+			type: "CONFIRM",
+			data: {
+				runnerId: this.#runnerId,
+				sessionId: this.#sessionId,
+				title,
+				description,
+				okButtonLabel,
+				cancelButtonLabel,
+				block,
+				executionContext: this.#executionContext
+			}
+		};
+		return new Promise(async (resolve, reject) => {
+			if (this.#signal.aborted) {
+				this.#logger.warn("confirm aborted before start");
+				return reject(/* @__PURE__ */ new Error("confirm aborted"));
+			}
+			this.#signal.addEventListener("abort", () => {
+				this.#logger.warn("confirm aborted");
+				reject(/* @__PURE__ */ new Error("confirm aborted"));
+			});
+			const resolveIO = async (receivedIOMessage) => {
+				this.#logger.debug({ message: receivedIOMessage }, "received confirm response from user");
+				if (receivedIOMessage.type === "CONFIRM_RESPONSE" && receivedIOMessage.rootMessageId === message.id) {
+					this.#pendingIOs.delete(message.id);
+					resolve(receivedIOMessage.data.confirmed);
+					runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+						id: nanoid(),
+						timestamp: Date.now(),
+						rootMessageId: message.id,
+						type: "CONFIRM_VALID",
+						data: {
+							sessionId: this.#sessionId,
+							executionContext: this.#executionContext
+						}
+					}));
+				}
+			};
+			try {
+				this.#logger.debug({ message }, "sending confirm message to worker");
+				this.#pendingIOs.set(message.id, resolveIO);
+				this.#logger.debug({ messageId: message.id }, "setup pending IO for confirm");
+				await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement(message));
+			} catch (error) {
+				this.#logger.error(error, "error during confirm");
+				reject(error);
+			}
+		});
+	}
+	/**
+	* Shows a message to the user.
+	*/
+	async message({ title, description, message }) {
+		await runWithRetries(() => this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: nanoid(),
+			timestamp: Date.now(),
+			type: "SHOW_MESSAGE",
+			data: {
+				sessionId: this.#sessionId,
+				message,
+				title,
+				description,
+				executionContext: this.#executionContext
+			}
+		}));
+	}
+};
+
+//#endregion
+//#region src/internal/tool.ts
+const TOOL_HANDLER_TAG_NAME = Symbol("TOOL_HANDLER");
+const TOOL_TAG_NAME = Symbol("TOOL");
+/**
+* Tool class is responsible for running the tool's logic.
+* It manages the tool lifecycle, communication with the worker, and handles sending messages back to the ForgeRunner.
+* It uses the IO component to facilitate input/output operations for the tool.
+*/
+var Tool = class {
+	#metadata;
+	#abortController = new AbortController();
+	#handler;
+	#io;
+	#block;
+	#logger;
+	constructor(options, logger) {
+		this.#metadata = options.metadata;
+		this.#handler = options.handler;
+		this.#logger = logger.child({
+			sessionId: this.#metadata.sessionId,
+			component: "TOOL"
+		});
+		this.#io = new IO({
+			sessionId: this.#metadata.sessionId,
+			runnerId: this.#metadata.runnerId,
+			webSocketClient: options.webSocketClient,
+			signal: this.#abortController.signal,
+			executionContext: { type: "TOOL" }
+		}, this.#logger);
+		this.#block = new Block({ signal: this.#abortController.signal });
+		this.#logger.debug("initialized Tool instance");
+	}
+	async run() {
+		return new Promise(async (resolve, reject) => {
+			if (this.#abortController.signal.aborted) {
+				this.#logger.info("tool execution aborted before start");
+				return Promise.reject(/* @__PURE__ */ new Error("tool execution aborted"));
+			}
+			this.#abortController.signal.addEventListener("abort", () => {
+				this.#logger.info("tool execution aborted");
+				reject(/* @__PURE__ */ new Error("Tool execution aborted"));
+			});
+			try {
+				this.#logger.info("running tool handler...");
+				const output = await this.#handler({
+					io: this.#io,
+					signal: this.#abortController.signal,
+					block: this.#block,
+					metadata: this.#metadata
+				});
+				this.#logger.info("tool handler completed successfully");
+				this.#io[STOP_SYMBOL]();
+				resolve(output);
+			} catch (error) {
+				this.#logger.error(error, "error running tool handler");
+				return reject(error);
+			}
+		});
+	}
+	stop() {
+		this.#logger.info("stopping Tool...");
+		this.#abortController.abort();
+		this.#logger.info("Tool stopped");
+	}
+};
+
+//#endregion
+//#region src/internal/workflow-builder.ts
+var WorkflowBuilder = class {
+	#logger;
+	#nodes = /* @__PURE__ */ new Set();
+	#edges = /* @__PURE__ */ new Map();
+	constructor(logger) {
+		this.#logger = logger.child({ component: "WORKFLOW_BUILDER" });
+		this.#nodes.add("START");
+		this.#nodes.add("END");
+	}
+	flow(from, to) {
+		this.#nodes.add(from);
+		this.#nodes.add(to);
+		if (!this.#edges.has(from)) this.#edges.set(from, []);
+		this.#edges.get(from).push({
+			type: "flow",
+			to,
+			from
+		});
+		return this;
+	}
+	branch(from, condition, targetMap) {
+		if (Object.keys(targetMap).length < 2) throw new Error(`branch from '${from}' must have at least 2 targets`);
+		this.#nodes.add(from);
+		for (const to of Object.values(targetMap)) this.#nodes.add(to);
+		if (!this.#edges.has(from)) this.#edges.set(from, []);
+		this.#edges.get(from).push({
+			type: "branch",
+			condition,
+			targetMap,
+			from
+		});
+		return this;
+	}
+	build() {
+		this.#validateStructure();
+		this.#validateEdges();
+		this.#validateConnectivity();
+		this.#logger.debug("workflow graph validated successfully");
+		return {
+			nodes: this.#nodes,
+			edges: this.#edges
+		};
+	}
+	/**
+	* Validate basic structure
+	*/
+	#validateStructure() {
+		if (!this.#nodes.has("START")) {
+			this.#logger.error("workflow must have START node");
+			throw new Error("workflow must have a START node");
+		}
+		if (!this.#nodes.has("END")) {
+			this.#logger.error("workflow must have END node");
+			throw new Error("workflow must have an END node");
+		}
+		if ((this.#edges.get("START") || []).length === 0) {
+			this.#logger.error("START node must have at least one outgoing edge");
+			throw new Error("START node must have at least one outgoing edge");
+		}
+		if ((this.#edges.get("END") || []).length > 0) {
+			this.#logger.error("END node cannot have outgoing edges");
+			throw new Error("END node cannot have outgoing edges");
+		}
+		const allEdges = Array.from(this.#edges.values()).flatMap((e) => e);
+		for (const edge of allEdges) {
+			if (edge.type === "flow" && edge.to === "START") {
+				this.#logger.error("START node cannot have incoming edges");
+				throw new Error("START node cannot have incoming edges");
+			}
+			if (edge.type === "branch" && Object.values(edge.targetMap).includes("START")) {
+				this.#logger.error("START node cannot have incoming edges");
+				throw new Error("START node cannot have incoming edges");
+			}
+		}
+	}
+	/**
+	* Validate edges
+	*/
+	#validateEdges() {
+		for (const [node, edges] of this.#edges.entries()) {
+			const hasFlow = edges.some((e) => e.type === "flow");
+			const hasBranch = edges.some((e) => e.type === "branch");
+			if (hasFlow && hasBranch) {
+				this.#logger.error(`node '${node}' cannot have both flow and branch edges`);
+				throw new Error(`node '${node}' cannot have both flow edges and branch edges. use either multiple flow edges OR one branch edge.`);
+			}
+			if (edges.length > 1 && hasBranch) {
+				this.#logger.error(`node '${node}' has multiple edges including a branch`);
+				throw new Error(`node '${node}' has multiple edges including a branch. a node can have only ONE branch edge.`);
+			}
+		}
+		const allEdges = Array.from(this.#edges.values()).flatMap((e) => e);
+		for (const edge of allEdges) if (edge.type === "branch") {
+			for (const [key, target] of Object.entries(edge.targetMap)) if (!this.#nodes.has(target)) {
+				this.#logger.error(`branch from '${edge.from}' has unknown target '${target}' for key '${key}'`);
+				throw new Error(`branch from '${edge.from}' has unknown target '${target}' for key '${key}'`);
+			}
+		}
+	}
+	/**
+	* Validate connectivity using BFS
+	*/
+	#validateConnectivity() {
+		const reachableFromStart = this.#getReachableNodes("START");
+		const unreachable = Array.from(this.#nodes).filter((node) => node !== "START" && !reachableFromStart.has(node));
+		if (unreachable.length > 0) {
+			this.#logger.error(`nodes unreachable from START: ${unreachable.join(", ")}`);
+			throw new Error(`nodes unreachable from START: ${unreachable.join(", ")}`);
+		}
+		if (!reachableFromStart.has("END")) {
+			this.#logger.error("END node is not reachable from START");
+			throw new Error("END node is not reachable from START");
+		}
+	}
+	/**
+	* Get all nodes reachable from a starting node (BFS)
+	*/
+	#getReachableNodes(start) {
+		const reachable = /* @__PURE__ */ new Set();
+		const queue = [start];
+		reachable.add(start);
+		while (queue.length > 0) {
+			const current = queue.shift();
+			const edges = this.#edges.get(current) || [];
+			for (const edge of edges) if (edge.type === "flow") {
+				if (!reachable.has(edge.to)) {
+					reachable.add(edge.to);
+					queue.push(edge.to);
+				}
+			} else if (edge.type === "branch") {
+				for (const target of Object.values(edge.targetMap)) if (!reachable.has(target)) {
+					reachable.add(target);
+					queue.push(target);
+				}
+			}
+		}
+		return reachable;
+	}
+};
+
+//#endregion
+//#region src/internal/agent.ts
+const AGENT_TAG_NAME = Symbol("AGENT");
+const AGENT_STEP_TAG_NAME = Symbol("AGENT_STEP");
+var Agent = class {
+	#logger;
+	#webSocketClient;
+	#abortController = new AbortController();
+	#metadata;
+	#stepDefinitions;
+	#bootstrap;
+	#workflowBuilder;
+	#workflowGraph;
+	#activeSteps = /* @__PURE__ */ new Set();
+	#MAX_ITERATIONS = 1e3;
+	#iterationCount = 0;
+	#contextSchema;
+	#context;
+	constructor(definition, options, logger) {
+		this.#metadata = options.metadata;
+		this.#stepDefinitions = definition.steps;
+		this.#bootstrap = definition.bootstrap;
+		this.#contextSchema = definition.contextSchema;
+		this.#webSocketClient = options.webSocketClient;
+		this.#logger = logger.child({
+			sessionId: this.#metadata.sessionId,
+			component: "AGENT"
+		});
+		this.#workflowBuilder = new WorkflowBuilder(this.#logger);
+		this.#workflowBuilder = definition.workflow(this.#workflowBuilder);
+		this.#workflowGraph = this.#workflowBuilder.build();
+	}
+	get #agentWorkflow() {
+		const nodeNames = Object.entries(this.#stepDefinitions).reduce((acc, [key, step]) => {
+			acc[key] = step.name ?? key;
+			return acc;
+		}, {});
+		function getNodeLabel(nodeId) {
+			if (nodeId === "START" || nodeId === "END") return nodeId;
+			return nodeNames[String(nodeId)] ?? nodeId;
+		}
+		return {
+			nodes: Array.from(this.#workflowGraph.nodes).map(getNodeLabel),
+			edges: Array.from(this.#workflowGraph.edges.values()).flat().map((edge) => {
+				if (edge.type === "flow") return {
+					type: "flow",
+					from: getNodeLabel(edge.from),
+					to: getNodeLabel(edge.to)
+				};
+				return {
+					type: "branch",
+					from: getNodeLabel(edge.from),
+					targetMap: Object.entries(edge.targetMap).reduce((acc, [key, target]) => {
+						acc[key] = getNodeLabel(target);
+						return acc;
+					}, {})
+				};
+			})
+		};
+	}
+	async run() {
+		await this.#webSocketClient.sendToServerWithAcknowledgement({
+			id: nanoid(),
+			timestamp: Date.now(),
+			type: "AGENT_START",
+			data: {
+				sessionId: this.#metadata.sessionId,
+				agentWorkflow: this.#agentWorkflow,
+				executionContext: { type: "AGENT" }
+			}
+		});
+		await this.#initializeContext();
+		invariant(this.#context, "agent context is not initialized");
+		this.#activeSteps.add("START");
+		while (this.#activeSteps.size > 0 && !this.#activeSteps.has("END") && this.#iterationCount < this.#MAX_ITERATIONS) {
+			this.#logger.debug({ activeSteps: Array.from(this.#activeSteps) }, "current active steps");
+			const stepsToExecute = Array.from(this.#activeSteps);
+			await this.#executeSteps(stepsToExecute);
+			const nextActiveSteps = /* @__PURE__ */ new Set();
+			for (const stepName of stepsToExecute) {
+				const edges = this.#workflowGraph.edges.get(stepName);
+				if (!edges) continue;
+				for (const edge of edges) if (edge.type === "flow") nextActiveSteps.add(edge.to);
+				else if (edge.type === "branch") {
+					const target = edge.condition(this.#context);
+					const nextStep = edge.targetMap[target];
+					if (nextStep) nextActiveSteps.add(nextStep);
+				}
+			}
+			this.#logger.debug({ nextActiveSteps: Array.from(nextActiveSteps) }, "next active steps");
+			this.#activeSteps = nextActiveSteps;
+			this.#iterationCount += 1;
+			this.#logger.debug({ iterationCount: this.#iterationCount }, "completed an iteration of the agent run loop");
+		}
+		return this.#context;
+	}
+	async #executeSteps(stepsToExecute) {
+		const stepDefinitions = stepsToExecute.filter((stepName) => stepName !== "START" && stepName !== "END").map((stepName) => {
+			const stepDef = this.#stepDefinitions[stepName];
+			if (!stepDef) throw new Error(`step definition not found for step: ${String(stepName)}`);
+			return {
+				name: stepName,
+				...stepDef
+			};
+		});
+		return Promise.all(stepDefinitions.map(async (stepDefinition) => {
+			invariant(this.#context, "agent context is not initialized");
+			const executionContext = {
+				id: nanoid(),
+				type: "STEP",
+				step: {
+					name: stepDefinition.name,
+					description: stepDefinition.description
+				}
+			};
+			const io = new IO({
+				webSocketClient: this.#webSocketClient,
+				executionContext,
+				runnerId: this.#metadata.runnerId,
+				sessionId: this.#metadata.sessionId,
+				signal: this.#abortController.signal
+			}, this.#logger);
+			const block = new Block({ signal: this.#abortController.signal });
+			try {
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_START",
+					data: {
+						sessionId: this.#metadata.sessionId,
+						executionContext
+					}
+				});
+				this.#logger.debug({ stepName: stepDefinition.name }, "executing agent step");
+				const output = await stepDefinition.handler({
+					io,
+					block,
+					context: this.#context,
+					updateContext: this.#updateContext.bind(this),
+					metadata: {
+						agentId: this.#metadata.agentId,
+						runnerId: this.#metadata.runnerId,
+						sessionId: this.#metadata.sessionId,
+						stepName: stepDefinition.name,
+						stepDescription: stepDefinition.description
+					},
+					signal: this.#abortController.signal
+				});
+				this.#logger.debug({
+					stepName: stepDefinition.name,
+					output
+				}, "agent step executed successfully");
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_COMPLETE",
+					data: {
+						output,
+						sessionId: this.#metadata.sessionId,
+						executionContext
+					}
+				});
+			} catch (error) {
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_ERROR",
+					data: {
+						executionContext,
+						error: {
+							message: getErrorMessage(error),
+							stack: error instanceof Error ? error.stack : void 0,
+							code: error instanceof Error && "code" in error ? String(error.code) : void 0
+						},
+						sessionId: this.#metadata.sessionId
+					}
+				});
+				this.#logger.error({ error }, "error executing step");
+				throw error;
+			} finally {
+				io[STOP_SYMBOL]();
+			}
+		}));
+	}
+	async #initializeContext() {
+		if (typeof this.#bootstrap === "function") {
+			const executionContext = {
+				type: "STEP",
+				id: nanoid(),
+				step: { name: "Bootstrap" }
+			};
+			const io = new IO({
+				webSocketClient: this.#webSocketClient,
+				executionContext,
+				runnerId: this.#metadata.runnerId,
+				sessionId: this.#metadata.sessionId,
+				signal: this.#abortController.signal
+			}, this.#logger);
+			const block = new Block({ signal: this.#abortController.signal });
+			try {
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_START",
+					data: {
+						sessionId: this.#metadata.sessionId,
+						executionContext
+					}
+				});
+				const initContext = await this.#bootstrap({
+					io,
+					block
+				});
+				this.#context = this.#contextSchema.parse(initContext);
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_COMPLETE",
+					data: {
+						output: "Bootstrap completed successfully",
+						sessionId: this.#metadata.sessionId,
+						executionContext
+					}
+				});
+			} catch (error) {
+				this.#logger.error({ error }, "Failed to bootstrap agent");
+				await this.#webSocketClient.sendToServerWithAcknowledgement({
+					id: nanoid(),
+					timestamp: Date.now(),
+					type: "STEP_ERROR",
+					data: {
+						executionContext,
+						error: {
+							message: getErrorMessage(error),
+							stack: error instanceof Error ? error.stack : void 0,
+							code: error instanceof Error && "code" in error ? String(error.code) : void 0
+						},
+						sessionId: this.#metadata.sessionId
+					}
+				});
+				throw error;
+			} finally {
+				io[STOP_SYMBOL]();
+			}
+		} else this.#context = this.#contextSchema.parse({});
+	}
+	#updateContext(updates) {
+		invariant(this.#context, "agent context is not initialized");
+		const newValues = typeof updates === "function" ? updates(this.#context) : updates;
+		this.#context = this.#contextSchema.parse({
+			...this.#context,
+			...newValues
+		});
+	}
+};
+
+//#endregion
+export { __toESM as C, __require as S, startAgentMessageSchema as _, TOOL_TAG_NAME as a, stopToolMessageSchema as b, getErrorMessage as c, runWithRetries as d, ackMessageSchema as f, runnerId as g, initCommunicationMessageSchema as h, TOOL_HANDLER_TAG_NAME as i, invariant as l, heartbeatAckMessageSchema as m, AGENT_TAG_NAME as n, Tool as o, baseMessageSchema as p, Agent as r, convertToWords as s, AGENT_STEP_TAG_NAME as t, exponentialBackoff as u, startToolMessageSchema as v, __commonJS as x, stopAgentMessageSchema as y };