@useago/sdk 1.5.3 → 1.5.4

package/dist/AgoClient-BW0YZsis.js

@@ -0,0 +1,1681 @@
+var Ut = 10, b = 1e3;
+function M(t) {
+  if (typeof t != "object" || t === null) return !1;
+  const e = Object.getPrototypeOf(t);
+  return e === Object.prototype || e === null;
+}
+function A(t, e) {
+  if (typeof t == "string") {
+    if (t.length <= 1e3) return t;
+    const s = t.length - b;
+    return t.slice(0, b) + `…[truncated ${s} chars]`;
+  }
+  if (Array.isArray(t)) {
+    if (e.has(t)) return "…[circular]";
+    e.add(t);
+    const s = t.slice(0, 50).map((i) => A(i, e));
+    return t.length > 50 && s.push(`…[+${t.length - 50} more]`), e.delete(t), s;
+  }
+  if (M(t)) {
+    if (e.has(t)) return "…[circular]";
+    e.add(t);
+    const s = {};
+    for (const [i, n] of Object.entries(t)) s[i] = A(n, e);
+    return e.delete(t), s;
+  }
+  return t;
+}
+function L(t) {
+  return A(t, /* @__PURE__ */ new WeakSet());
+}
+var j = class {
+  constructor(t = 10) {
+    this.entries = [];
+    const e = Math.floor(t);
+    this.maxEntries = Number.isFinite(e) ? Math.max(1, e) : 10;
+  }
+  add(t) {
+    const e = {
+      ts: t.ts ?? Date.now(),
+      actor: t.actor ?? "user",
+      name: t.name,
+      summary: t.summary,
+      ...t.data !== void 0 ? { data: L(t.data) } : {}
+    };
+    this.entries.push(e);
+    const s = this.entries.length - this.maxEntries;
+    return s > 0 && this.entries.splice(0, s), e;
+  }
+  getRecent() {
+    return [...this.entries];
+  }
+  get size() {
+    return this.entries.length;
+  }
+  clear() {
+    this.entries = [];
+  }
+}, g = class extends Error {
+  constructor(t, e, s) {
+    super(t), this.code = e, this.statusCode = s, this.name = "AgoError";
+  }
+}, p = class P extends g {
+  constructor(e, s, i, n, o, a) {
+    super(e, s, i), this.type = n, this.param = o, this.docUrl = a, this.name = "AgoApiError";
+  }
+  static fromResponse(e, s) {
+    const i = e.error;
+    return new P(i.doc_url ? `${i.message} See ${i.doc_url}` : i.message, i.code, s, i.type, i.param, i.doc_url);
+  }
+}, w = class extends g {
+  constructor(t, e) {
+    super(t, "network_error"), this.originalError = e, this.name = "AgoNetworkError";
+  }
+}, k = class extends g {
+  constructor(t, e = "stream_error") {
+    super(t, e), this.name = "AgoStreamError";
+  }
+}, R = class extends g {
+  constructor(t, e, s) {
+    super(t, "function_error"), this.functionName = e, this.originalError = s, this.name = "AgoFunctionError";
+  }
+}, B = class {
+  constructor(t = !1) {
+    this.enabled = t;
+  }
+  enable() {
+    this.enabled = !0;
+  }
+  disable() {
+    this.enabled = !1;
+  }
+  log(...t) {
+    this.enabled && console.log("[AGO SDK]", ...t);
+  }
+  warn(...t) {
+    this.enabled && console.warn("[AGO SDK]", ...t);
+  }
+  error(...t) {
+    console.error("[AGO SDK]", ...t);
+  }
+  debug(...t) {
+    this.enabled && console.debug("[AGO SDK]", ...t);
+  }
+}, c = new B(), I = "ago_widget_id";
+function G() {
+  if (typeof localStorage < "u") {
+    const e = localStorage.getItem(I);
+    if (e) return e;
+  }
+  const t = typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `ago-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+  if (typeof localStorage < "u") try {
+    localStorage.setItem(I, t);
+  } catch {
+  }
+  return t;
+}
+var K = class {
+  constructor(t) {
+    this.baseUrl = t.baseUrl.replace(/\/$/, ""), this.headers = { "X-User-Anon-Id": t.widgetId || G() }, t.userEmail && (this.headers["X-User-Email"] = t.userEmail), t.userJwt && (this.headers.Authorization = `Bearer ${t.userJwt}`), t.permission && (this.headers["X-Widget-Permission"] = t.permission);
+  }
+  updateConfig(t) {
+    t.baseUrl && (this.baseUrl = t.baseUrl.replace(/\/$/, "")), t.widgetId && (this.headers["X-User-Anon-Id"] = t.widgetId), t.userEmail && (this.headers["X-User-Email"] = t.userEmail), t.userJwt && (this.headers.Authorization = `Bearer ${t.userJwt}`), t.permission !== void 0 && (t.permission ? this.headers["X-Widget-Permission"] = t.permission : delete this.headers["X-Widget-Permission"]);
+  }
+  async get(t) {
+    return this.request("GET", t);
+  }
+  async post(t, e, s) {
+    return this.request("POST", t, e, s);
+  }
+  async postStream(t, e) {
+    const s = `${this.baseUrl}${t}`;
+    c.debug("POST (stream)", s, e);
+    try {
+      const i = await fetch(s, {
+        method: "POST",
+        headers: {
+          ...this.headers,
+          "Content-Type": "application/json"
+        },
+        body: e ? JSON.stringify(e) : void 0
+      });
+      return i.ok || await this.handleErrorResponse(i), i;
+    } catch (i) {
+      throw i instanceof p ? i : new w(`Network error: ${i instanceof Error ? i.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, i instanceof Error ? i : void 0);
+    }
+  }
+  async postFormData(t, e) {
+    const s = `${this.baseUrl}${t}`;
+    c.debug("POST (formData)", s);
+    const i = { ...this.headers };
+    try {
+      const n = await fetch(s, {
+        method: "POST",
+        headers: i,
+        body: e
+      });
+      return n.ok || await this.handleErrorResponse(n), n;
+    } catch (n) {
+      throw n instanceof p ? n : new w(`Network error: ${n instanceof Error ? n.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, n instanceof Error ? n : void 0);
+    }
+  }
+  async request(t, e, s, i) {
+    const n = `${this.baseUrl}${e}`;
+    c.debug(t, n, s);
+    try {
+      const o = await fetch(n, {
+        method: t,
+        headers: {
+          ...this.headers,
+          "Content-Type": "application/json"
+        },
+        body: s ? JSON.stringify(s) : void 0,
+        ...i?.keepalive ? { keepalive: !0 } : {}
+      });
+      return o.ok || await this.handleErrorResponse(o), o.status === 204 ? void 0 : o.json();
+    } catch (o) {
+      throw o instanceof p ? o : new w(`Network error: ${o instanceof Error ? o.message : "Unknown error"}. Check that \`baseUrl\` is reachable and includes the protocol (https://).`, o instanceof Error ? o : void 0);
+    }
+  }
+  async handleErrorResponse(t) {
+    let e;
+    try {
+      e = await t.json();
+    } catch {
+    }
+    if (e?.error) throw p.fromResponse(e, t.status);
+    let s = "";
+    throw t.status === 401 || t.status === 403 ? s = " Check `userJwt` (and that it has not expired)." : t.status === 404 && (s = " Check that `baseUrl` points at your AGO API root."), new p(`HTTP ${t.status}: ${t.statusText}.${s}`, "http_error", t.status, "api_error");
+  }
+}, W = 5e4, q = 2e4, H = 2e3, J = class {
+  constructor(t) {
+    this.functions = /* @__PURE__ */ new Map(), this.defaultMaxResultBytes = t?.maxResultBytes ?? W;
+  }
+  setDefaultMaxResultBytes(t) {
+    this.defaultMaxResultBytes = t;
+  }
+  register(t, e, s) {
+    if (typeof t == "object") {
+      const { name: r, handler: l, description: h, parameters: u, maxResultBytes: d, requiresApproval: m } = t;
+      return this.register(r, l, {
+        description: h,
+        parameters: u,
+        maxResultBytes: d,
+        requiresApproval: m
+      });
+    }
+    const i = t;
+    if (!e || !s) throw new g(`registerFunction("${i}"): both a handler and a schema are required. Pass them as arguments or use the single-object form: registerFunction({ name, parameters, handler }).`, "function_invalid_registration");
+    this.functions.has(i) && c.warn(`Function "${i}" is being overwritten`);
+    const { maxResultBytes: n, requiresApproval: o, ...a } = s;
+    this.functions.set(i, {
+      schema: {
+        ...a,
+        name: i
+      },
+      handler: e,
+      maxResultBytes: n,
+      requiresApproval: o
+    }), c.log(`Registered function: ${i}`);
+  }
+  unregister(t) {
+    const e = this.functions.delete(t);
+    return e && c.log(`Unregistered function: ${t}`), e;
+  }
+  get(t) {
+    return this.functions.get(t);
+  }
+  has(t) {
+    return this.functions.has(t);
+  }
+  getSchemas() {
+    return Array.from(this.functions.values()).map((t) => t.schema);
+  }
+  async execute(t, e) {
+    const s = this.functions.get(t);
+    if (!s) throw new R(`Function "${t}" is not registered`, t);
+    c.log(`Executing function: ${t}`, e);
+    try {
+      const i = await s.handler(e);
+      return c.log(`Function ${t} completed:`, i), this.guardResultSize(t, i, s.maxResultBytes);
+    } catch (i) {
+      throw c.error(`Function ${t} failed:`, i), new R(`Function "${t}" execution failed: ${i instanceof Error ? i.message : "Unknown error"}`, t, i instanceof Error ? i : void 0);
+    }
+  }
+  guardResultSize(t, e, s) {
+    let i;
+    try {
+      i = JSON.stringify(e);
+    } catch {
+      return e;
+    }
+    if (i === void 0) return e;
+    const n = new TextEncoder().encode(i).length, o = s ?? this.defaultMaxResultBytes;
+    return n > o ? (c.warn(`Function "${t}" result is ${n} bytes, over the ${o}-byte limit; a truncated preview was sent to the agent instead. Return fewer fields, paginate, or raise maxResultBytes for this function.`), {
+      truncated: !0,
+      originalBytes: n,
+      maxBytes: o,
+      preview: i.slice(0, H),
+      hint: `The result of "${t}" exceeded the ${o}-byte limit and was truncated. Request less data (use limit or filter parameters if available), or tell the user the result is too large to process.`
+    }) : (n > q && c.warn(`Function "${t}" returned a large result (${Math.round(n / 1024)} KB). Large results consume LLM context: return fewer fields, paginate, or push the data to the UI and return a summary.`), e);
+  }
+  clear() {
+    this.functions.clear(), c.log("Cleared all registered functions");
+  }
+  get size() {
+    return this.functions.size;
+  }
+}, X = 250, Y = 3, z = 1e3, V = 24, Q = 10, Z = 50, tt = [
+  "mousemove",
+  "mousedown",
+  "keydown",
+  "scroll",
+  "touchstart"
+], et = class {
+  constructor(t = {}) {
+    this.started = !1, this.teardowns = [], this.route = "", this.routeEnteredAt = 0, this.lastActivityAt = 0, this.lastHeavyActivityAt = 0, this.recentRoutes = [], this.routeBounces = 0, this.rageClicks = 0, this.fieldErrors = {}, this.recentClicks = [], this.signals = [], this.listeners = /* @__PURE__ */ new Set(), this.getPageState = t.getPageState, this.activityThrottleMs = t.activityThrottleMs ?? X, this.rageClickCount = t.rageClickCount ?? Y, this.rageClickWindowMs = t.rageClickWindowMs ?? z, this.rageClickRadiusPx = t.rageClickRadiusPx ?? V, this.maxRecentRoutes = t.maxRecentRoutes ?? Q, this.maxSignals = t.maxSignals ?? Z;
+  }
+  start() {
+    if (this.started || typeof window > "u" || typeof document > "u") return;
+    this.started = !0;
+    const t = Date.now();
+    this.route = this.currentPathname(), this.routeEnteredAt = t, this.lastActivityAt = t, this.recentRoutes = [this.route];
+    const e = (i, n, o) => {
+      i.addEventListener(n, o, { passive: !0 }), this.teardowns.push(() => i.removeEventListener(n, o));
+    }, s = () => this.recordActivity();
+    for (const i of tt) e(window, i, s);
+    e(document, "visibilitychange", () => {
+      document.visibilityState === "visible" && this.recordActivity();
+    }), e(window, "popstate", () => this.checkRoute()), e(window, "hashchange", () => this.checkRoute()), e(window, "click", (i) => this.onClick(i)), c.log("SignalCollector started");
+  }
+  destroy() {
+    for (const t of this.teardowns) t();
+    this.teardowns = [], this.listeners.clear(), this.recentClicks = [], this.started = !1, c.log("SignalCollector destroyed");
+  }
+  signalFieldError(t) {
+    this.checkRoute();
+    const e = (this.fieldErrors[t] ?? 0) + 1;
+    this.fieldErrors[t] = e, this.pushSignal({
+      type: "field_error",
+      route: this.route,
+      at: Date.now(),
+      count: e,
+      meta: { field: t }
+    });
+  }
+  subscribe(t) {
+    return this.listeners.add(t), () => {
+      this.listeners.delete(t);
+    };
+  }
+  getSignals() {
+    return [...this.signals];
+  }
+  getSnapshot(t) {
+    this.checkRoute();
+    const e = Date.now();
+    return {
+      route: this.route,
+      dwellMs: this.started ? e - this.routeEnteredAt : 0,
+      idleMs: this.started ? e - this.lastActivityAt : 0,
+      rageClicks: this.rageClicks,
+      routeBounces: this.routeBounces,
+      fieldErrors: { ...this.fieldErrors },
+      recentRoutes: [...this.recentRoutes],
+      pageState: t?.pageState === !1 ? null : this.readPageState()
+    };
+  }
+  currentPathname() {
+    return typeof window < "u" && window.location ? window.location.pathname : "";
+  }
+  readPageState() {
+    if (!this.getPageState) return null;
+    try {
+      return this.getPageState() ?? null;
+    } catch (t) {
+      return c.warn("SignalCollector getPageState threw:", t), null;
+    }
+  }
+  recordActivity() {
+    const t = Date.now();
+    this.lastActivityAt = t, t - this.lastHeavyActivityAt >= this.activityThrottleMs && (this.lastHeavyActivityAt = t, this.checkRoute());
+  }
+  checkRoute() {
+    if (!this.started) return;
+    const t = this.currentPathname();
+    if (t === this.route) return;
+    const e = Date.now(), s = this.route;
+    this.route = t, this.routeEnteredAt = e, this.rageClicks = 0, this.fieldErrors = {}, this.recentClicks = [], this.recentRoutes.push(t), this.recentRoutes.length > this.maxRecentRoutes && this.recentRoutes.splice(0, this.recentRoutes.length - this.maxRecentRoutes), this.pushSignal({
+      type: "route_change",
+      route: t,
+      at: e,
+      meta: { from: s }
+    });
+    const i = this.recentRoutes, n = i.length;
+    n >= 4 && i[n - 1] === i[n - 3] && i[n - 2] === i[n - 4] && i[n - 1] !== i[n - 2] && (this.routeBounces += 1, this.pushSignal({
+      type: "route_bounce",
+      route: t,
+      at: e,
+      count: this.routeBounces,
+      meta: { between: `${i[n - 2]}↔${i[n - 1]}` }
+    }));
+  }
+  onClick(t) {
+    this.recordActivity();
+    const e = Date.now(), s = this.pageStateKey(), i = {
+      at: e,
+      x: t.clientX,
+      y: t.clientY,
+      stateKey: s
+    };
+    this.recentClicks = this.recentClicks.filter((r) => e - r.at <= this.rageClickWindowMs);
+    const n = this.recentClicks[0], o = !n || Math.abs(i.x - n.x) <= this.rageClickRadiusPx && Math.abs(i.y - n.y) <= this.rageClickRadiusPx, a = !n || n.stateKey === s;
+    if (!o || !a) {
+      this.recentClicks = [i];
+      return;
+    }
+    this.recentClicks.push(i), this.recentClicks.length >= this.rageClickCount && (this.rageClicks += 1, this.recentClicks = [], this.pushSignal({
+      type: "rage_click",
+      route: this.route,
+      at: e,
+      count: this.rageClicks
+    }));
+  }
+  pageStateKey() {
+    const t = this.readPageState();
+    if (!t) return "";
+    try {
+      return JSON.stringify(t);
+    } catch {
+      return "";
+    }
+  }
+  pushSignal(t) {
+    this.signals.push(t), this.signals.length > this.maxSignals && this.signals.splice(0, this.signals.length - this.maxSignals);
+    for (const e of this.listeners) try {
+      e(t);
+    } catch (s) {
+      c.error("Signal listener threw:", s);
+    }
+  }
+};
+function st(t, e) {
+  const s = e ? e.storage ?? (typeof localStorage < "u" ? localStorage : void 0) : void 0;
+  let i = t;
+  if (e && s) try {
+    const r = s.getItem(e.key);
+    r != null && (i = JSON.parse(r));
+  } catch {
+  }
+  const n = /* @__PURE__ */ new Set(), o = () => n.forEach((r) => r(i));
+  function a() {
+    if (e && s) try {
+      s.setItem(e.key, JSON.stringify(i));
+    } catch {
+    }
+  }
+  return {
+    get: () => i,
+    set: (r) => {
+      i = r, a(), o();
+    },
+    subscribe: (r) => (n.add(r), () => {
+      n.delete(r);
+    })
+  };
+}
+var it = 6e4, nt = 1440 * 60 * 1e3, rt = "ago_proactive";
+function C(t) {
+  const e = new Date(t), s = String(e.getMonth() + 1).padStart(2, "0"), i = String(e.getDate()).padStart(2, "0");
+  return `${e.getFullYear()}-${s}-${i}`;
+}
+var ot = class {
+  constructor(t = {}) {
+    this.killSwitchEnabled = !1, this.engaged = !1, this.turnInFlight = !1, this.slotOccupied = !1, this.sessionCount = 0, this.perSessionCap = t.frequencyCap?.perSession, this.perDayCap = t.frequencyCap?.perDay, this.store = st({
+      optOut: !1,
+      lastFiredAt: {},
+      dismissedAt: {},
+      day: {
+        date: C(Date.now()),
+        count: 0
+      }
+    }, {
+      key: t.storageKey ?? rt,
+      storage: t.storage
+    });
+  }
+  setKillSwitch(t) {
+    this.killSwitchEnabled = t;
+  }
+  optOut() {
+    this.store.set({
+      ...this.store.get(),
+      optOut: !0
+    });
+  }
+  optIn() {
+    this.store.set({
+      ...this.store.get(),
+      optOut: !1
+    });
+  }
+  isOptedOut() {
+    return this.store.get().optOut;
+  }
+  setEngaged(t) {
+    this.engaged = t;
+  }
+  setTurnInFlight(t) {
+    this.turnInFlight = t;
+  }
+  isSlotOccupied() {
+    return this.slotOccupied;
+  }
+  occupySlot() {
+    this.slotOccupied = !0;
+  }
+  releaseSlot() {
+    this.slotOccupied = !1;
+  }
+  canFire(t, e = Date.now()) {
+    if (!this.killSwitchEnabled) return this.deny(t, "kill-switch (proactive disabled server-side)");
+    const s = this.store.get();
+    if (s.optOut) return this.deny(t, "user opted out");
+    if (this.engaged) return this.deny(t, "user engaged (widget open)");
+    if (this.turnInFlight) return this.deny(t, "message turn in flight");
+    if (this.slotOccupied) return this.deny(t, "nudge slot occupied");
+    const i = s.lastFiredAt[t.id], n = t.cooldownMs ?? it;
+    if (i !== void 0 && e - i < n) return this.deny(t, "cooldown");
+    const o = s.dismissedAt[t.id], a = t.resurfaceAfterMs ?? nt;
+    return o !== void 0 && e - o < a ? this.deny(t, "dismissed recently") : this.perSessionCap !== void 0 && this.sessionCount >= this.perSessionCap ? this.deny(t, "perSession cap") : this.perDayCap !== void 0 && this.dayCount(e) >= this.perDayCap ? this.deny(t, "perDay cap") : !0;
+  }
+  recordFired(t, e = Date.now()) {
+    const s = this.store.get();
+    this.store.set({
+      ...s,
+      lastFiredAt: {
+        ...s.lastFiredAt,
+        [t]: e
+      }
+    });
+  }
+  recordNudgeShown(t = Date.now()) {
+    this.sessionCount += 1;
+    const e = this.store.get(), s = C(t), i = e.day.date === s ? {
+      date: s,
+      count: e.day.count + 1
+    } : {
+      date: s,
+      count: 1
+    };
+    this.store.set({
+      ...e,
+      day: i
+    });
+  }
+  recordDismissed(t, e = Date.now()) {
+    const s = this.store.get();
+    this.store.set({
+      ...s,
+      dismissedAt: {
+        ...s.dismissedAt,
+        [t]: e
+      }
+    });
+  }
+  dayCount(t) {
+    const e = this.store.get();
+    return e.day.date === C(t) ? e.day.count : 0;
+  }
+  deny(t, e) {
+    return c.debug(`NudgeGovernor: trigger "${t.id}" blocked — ${e}`), !1;
+  }
+};
+function x() {
+  return typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (t) => {
+    const e = Math.floor(Math.random() * 16);
+    return (t === "x" ? e : e & 3 | 8).toString(16);
+  });
+}
+function at(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function ct(t, e) {
+  if (t === "*" || t === e) return !0;
+  const s = t.split("/"), i = s.map((n, o) => {
+    const a = o === s.length - 1;
+    return n === "*" ? a ? "[^/]+(?:/[^/]+)*" : "[^/]+" : n.startsWith(":") ? "[^/]+" : at(n);
+  });
+  return new RegExp("^" + i.join("/") + "/?$").test(e);
+}
+function O(t, e) {
+  return t === e ? !0 : t === null || e === null ? !1 : Array.isArray(t) ? !Array.isArray(e) || e.length !== t.length ? !1 : t.every((s, i) => E(s, e[i])) : typeof t == "object" ? typeof e != "object" || Array.isArray(e) ? !1 : Object.entries(t).every(([s, i]) => O(i, e[s])) : !1;
+}
+function E(t, e) {
+  if (t === e) return !0;
+  if (t === null || e === null || typeof t != typeof e) return !1;
+  if (Array.isArray(t))
+    return !Array.isArray(e) || t.length !== e.length ? !1 : t.every((s, i) => E(s, e[i]));
+  if (typeof t == "object") {
+    const s = Object.keys(t), i = Object.keys(e);
+    return s.length !== i.length ? !1 : s.every((n) => E(t[n], e[n]));
+  }
+  return !1;
+}
+function lt(t, e) {
+  if (t.route !== void 0 && !ct(t.route, e.route) || t.idleMs !== void 0 && e.idleMs < t.idleMs || t.dwellMs !== void 0 && e.dwellMs < t.dwellMs || t.rageClicks !== void 0 && e.rageClicks < t.rageClicks || t.routeBounces !== void 0 && e.routeBounces < t.routeBounces) return !1;
+  if (t.fieldErrors !== void 0) {
+    for (const [s, i] of Object.entries(t.fieldErrors)) if ((e.fieldErrors[s] ?? 0) < i) return !1;
+  }
+  return !(t.pageState !== void 0 && !O(t.pageState, e.pageState ?? {}));
+}
+var ht = 1e3, ut = "/api/sdk/v1/config", dt = "/api/sdk/v1/proactive/evaluate", gt = class {
+  constructor(t) {
+    this.tickTimer = null, this.teardowns = [], this.started = !1, this.activeNudge = null, this.lastConversationId = null, this.shownIds = /* @__PURE__ */ new Set(), this.resolvedIds = /* @__PURE__ */ new Set(), this.lastEvaluationAt = 0, this.client = t.client, this.collector = t.collector, this.governor = t.governor, this.tracker = t.tracker, this.options = t.options, this.tickMs = t.options.tickMs ?? ht;
+  }
+  start() {
+    if (this.started) return;
+    this.started = !0, this.options.enabledOverride !== void 0 ? this.governor.setKillSwitch(this.options.enabledOverride) : this.loadKillSwitch();
+    const t = (n) => {
+      n.conversationId && (this.lastConversationId = n.conversationId), this.governor.setTurnInFlight(!0);
+    }, e = () => this.governor.setTurnInFlight(!1), s = () => this.governor.setTurnInFlight(!1), i = (n) => {
+      n?.id && (this.lastConversationId = n.id);
+    };
+    this.client.on("message:start", t), this.client.on("message:complete", e), this.client.on("message:error", s), this.client.on("conversation:loaded", i), this.teardowns.push(() => {
+      this.client.off("message:start", t), this.client.off("message:complete", e), this.client.off("message:error", s), this.client.off("conversation:loaded", i);
+    }), this.tickTimer = setInterval(() => this.evaluate(), this.tickMs), this.teardowns.push(this.collector.subscribe(() => {
+      Date.now() - this.lastEvaluationAt >= this.tickMs && this.evaluate();
+    }));
+  }
+  stop() {
+    this.tickTimer !== null && (clearInterval(this.tickTimer), this.tickTimer = null);
+    for (const t of this.teardowns) t();
+    this.teardowns = [], this.started = !1;
+  }
+  getActiveNudge() {
+    return this.activeNudge;
+  }
+  async loadKillSwitch() {
+    try {
+      const t = await this.client.getHttp().get(ut);
+      this.governor.setKillSwitch(t?.proactive?.enabled === !0);
+    } catch (t) {
+      c.debug("Proactive config fetch failed; staying disabled:", t), this.governor.setKillSwitch(!1);
+    }
+  }
+  evaluate() {
+    if (this.lastEvaluationAt = Date.now(), typeof document < "u" && document.visibilityState === "hidden" || this.governor.isSlotOccupied()) return;
+    const t = this.collector.getSnapshot();
+    for (const e of this.options.triggers)
+      if (lt(e.when, t) && this.governor.canFire(e)) {
+        this.fire(e);
+        return;
+      }
+  }
+  fire(t) {
+    if (this.governor.recordFired(t.id), this.governor.occupySlot(), t.intervene === "agent") {
+      this.evaluateWithAgent(t);
+      return;
+    }
+    this.setReady({
+      id: x(),
+      triggerId: t.id,
+      source: "static",
+      message: t.intervene.message,
+      action: t.intervene.action,
+      goal: t.goal,
+      kickoff: t.kickoff,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  async evaluateWithAgent(t) {
+    const e = x(), s = {
+      client_nudge_id: e,
+      trigger_id: t.id,
+      goal: t.goal ?? "",
+      agent: this.client.getConfiguredAgent(),
+      signals: this.collector.getSnapshot(),
+      client_context: this.client.getContextSnapshot() ?? { entries: {} },
+      client_functions: this.client.getRegisteredFunctions()
+    };
+    let i;
+    try {
+      i = await this.client.getHttp().post(dt, s);
+    } catch (n) {
+      c.debug("Proactive evaluate failed (treated as no-intervene):", n), this.governor.releaseSlot();
+      return;
+    }
+    if (!i?.intervene || !i.message) {
+      this.governor.releaseSlot();
+      return;
+    }
+    this.setReady({
+      id: e,
+      triggerId: t.id,
+      source: "agent",
+      message: i.message,
+      action: ft(i.action),
+      goal: t.goal,
+      kickoff: t.kickoff,
+      createdAt: /* @__PURE__ */ new Date(),
+      serverNudgeId: i.nudge_id
+    });
+  }
+  setReady(t) {
+    this.activeNudge = t, this.client.emitProactiveEvent("nudge:ready", t);
+  }
+  shown(t) {
+    this.shownIds.has(t.id) || (this.shownIds.add(t.id), this.governor.recordNudgeShown(), this.tracker.track({
+      clientNudgeId: t.id,
+      triggerId: t.triggerId,
+      source: t.source,
+      type: "shown",
+      message: t.message,
+      occurredAt: Date.now()
+    }), this.client.emitProactiveEvent("nudge:shown", { nudge: t }));
+  }
+  dismiss(t) {
+    this.resolvedIds.has(t.id) || (this.resolvedIds.add(t.id), this.governor.recordDismissed(t.triggerId), this.tracker.track({
+      clientNudgeId: t.id,
+      triggerId: t.triggerId,
+      source: t.source,
+      type: "dismissed",
+      occurredAt: Date.now()
+    }), this.clearActive(t), this.client.emitProactiveEvent("nudge:dismissed", { nudge: t }));
+  }
+  async accept(t) {
+    this.resolvedIds.has(t.id) || (this.resolvedIds.add(t.id), this.tracker.track({
+      clientNudgeId: t.id,
+      triggerId: t.triggerId,
+      source: t.source,
+      type: "accepted",
+      occurredAt: Date.now()
+    }), this.clearActive(t), this.client.emitProactiveEvent("nudge:accepted", { nudge: t }), (t.source === "agent" || t.goal) && (this.lastConversationId ? this.client.sendMessage(pt(t), {
+      hidden: !0,
+      conversationId: this.lastConversationId
+    }).catch((e) => c.debug("Nudge kickoff message failed:", e)) : t.kickoff ? this.client.sendMessage(t.kickoff).catch((e) => c.debug("Nudge kickoff message failed:", e)) : c.debug("Nudge accepted with no open conversation and no trigger.kickoff; skipping the chat pre-seed (a hidden message cannot open a conversation).")), t.action && await this.runAction(t.action));
+  }
+  markConverted(t) {
+    this.tracker.track({
+      clientNudgeId: t.id,
+      triggerId: t.triggerId,
+      source: t.source,
+      type: "converted",
+      occurredAt: Date.now()
+    });
+  }
+  clearActive(t) {
+    this.activeNudge?.id === t.id && (this.activeNudge = null), this.governor.releaseSlot();
+  }
+  async runAction(t) {
+    try {
+      "functionName" in t ? await this.client.executeClientFunction(t.functionName, t.arguments ?? {}) : await this.client.executeClientFunction("setPageState", t.setPageState);
+    } catch (e) {
+      c.warn("Nudge action failed:", e);
+    }
+  }
+};
+function ft(t) {
+  if (t)
+    return {
+      label: t.label,
+      functionName: t.function_name,
+      arguments: t.arguments
+    };
+}
+function pt(t) {
+  const e = t.goal ? ` Goal: ${t.goal}.` : "";
+  return `The user accepted a proactive nudge that said: "${t.message}".${e} Recent friction signals are in the client context (friction_signals). Start helping with this now: briefly explain what you can do and take the first concrete step.`;
+}
+var mt = 5e3, yt = "/api/sdk/v1/proactive/events", vt = class {
+  constructor(t) {
+    if (this.queue = [], this.flushTimer = null, this.teardowns = [], this.destroyed = !1, this.post = t.post, this.agent = t.agent, this.flushIntervalMs = t.flushIntervalMs ?? mt, typeof document < "u") {
+      const e = () => {
+        document.visibilityState === "hidden" && this.flush({ keepalive: !0 });
+      };
+      document.addEventListener("visibilitychange", e), this.teardowns.push(() => document.removeEventListener("visibilitychange", e));
+    }
+    if (typeof window < "u") {
+      const e = () => this.flush({ keepalive: !0 });
+      window.addEventListener("pagehide", e), this.teardowns.push(() => window.removeEventListener("pagehide", e));
+    }
+  }
+  track(t) {
+    this.destroyed || (this.queue.push(t), this.flushTimer === null && (this.flushTimer = setTimeout(() => this.flush(), this.flushIntervalMs)));
+  }
+  flush(t) {
+    if (this.flushTimer !== null && (clearTimeout(this.flushTimer), this.flushTimer = null), this.queue.length === 0) return;
+    const e = this.queue;
+    this.queue = [];
+    const s = { events: e.map((i) => ({
+      client_nudge_id: i.clientNudgeId,
+      trigger_id: i.triggerId,
+      source: i.source,
+      type: i.type,
+      ...i.message !== void 0 ? { message: i.message } : {},
+      ...this.agent ? { agent: this.agent } : {},
+      occurred_at: new Date(i.occurredAt).toISOString()
+    })) };
+    this.post(yt, s, t).catch((i) => {
+      c.debug("Proactive event batch failed:", i);
+    });
+  }
+  destroy() {
+    if (!this.destroyed) {
+      this.flush({ keepalive: !0 }), this.destroyed = !0;
+      for (const t of this.teardowns) t();
+      this.teardowns = [];
+    }
+  }
+}, T = "friction_signals";
+function F(t, e) {
+  t.proactive && (c.warn("createAgoProactive: a proactive controller is already attached; replacing it."), t.proactive.destroy());
+  const s = new et({
+    ...e.signals,
+    getPageState: () => {
+      const r = t.getContextSnapshot();
+      if (!r) return null;
+      const l = {};
+      for (const [h, u] of Object.entries(r.entries)) h.startsWith("page-state:") && u.data && Object.assign(l, u.data);
+      return Object.keys(l).length > 0 ? l : null;
+    }
+  });
+  s.start(), t.addDynamicContext(T, () => {
+    const { pageState: r, ...l } = s.getSnapshot({ pageState: !1 });
+    return {
+      name: "Friction signals",
+      description: "Behavioral friction observed on the current page: dwell/idle times, rage clicks, route bounces, repeated field errors (names and counters only).",
+      data: l
+    };
+  });
+  const i = new ot({
+    frequencyCap: e.frequencyCap,
+    storage: e.storage,
+    storageKey: e.storageKey
+  }), n = new vt({
+    post: (r, l, h) => t.getHttp().post(r, l, h),
+    agent: t.getConfiguredAgent()
+  }), o = new gt({
+    client: t,
+    collector: s,
+    governor: i,
+    tracker: n,
+    options: e
+  });
+  o.start();
+  const a = {
+    optOut: () => i.optOut(),
+    optIn: () => i.optIn(),
+    isOptedOut: () => i.isOptedOut(),
+    setEngaged: (r) => i.setEngaged(r),
+    signalFieldError: (r) => s.signalFieldError(r),
+    getSignalsSnapshot: () => s.getSnapshot(),
+    getActiveNudge: () => o.getActiveNudge(),
+    shown: (r) => o.shown(r),
+    accept: (r) => o.accept(r),
+    dismiss: (r) => o.dismiss(r),
+    markConverted: (r) => o.markConverted(r),
+    destroy: () => {
+      o.stop(), n.destroy(), s.destroy(), t.removeDynamicContext(T), t.proactive === a && (t.proactive = null);
+    }
+  };
+  return t.proactive = a, a;
+}
+var wt = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map(), this.dynamicProviders = /* @__PURE__ */ new Map();
+  }
+  set(t, e) {
+    this.entries.set(t, e), c.log(`ClientContext set: ${t}`);
+  }
+  remove(t) {
+    const e = this.entries.delete(t);
+    return e && c.log(`ClientContext removed: ${t}`), e;
+  }
+  addDynamicProvider(t, e) {
+    this.dynamicProviders.set(t, e), c.log(`DynamicContext provider added: ${t}`);
+  }
+  removeDynamicProvider(t) {
+    const e = this.dynamicProviders.delete(t);
+    return e && c.log(`DynamicContext provider removed: ${t}`), e;
+  }
+  getSnapshot() {
+    if (this.entries.size === 0 && this.dynamicProviders.size === 0) return null;
+    const t = {};
+    for (const [e, s] of this.entries) t[e] = s;
+    for (const [e, s] of this.dynamicProviders) try {
+      const i = s();
+      i && (t[e] = i);
+    } catch (i) {
+      c.error(`DynamicContext provider "${e}" threw:`, i);
+    }
+    return Object.keys(t).length === 0 ? null : { entries: t };
+  }
+  clear() {
+    this.entries.clear(), this.dynamicProviders.clear(), c.log("ClientContext cleared");
+  }
+}, Ct = "page-state:";
+function St(t) {
+  const e = {};
+  for (const [s, i] of Object.entries(t)) s.startsWith(Ct) && i.data && Object.assign(e, i.data);
+  return e;
+}
+function At(t) {
+  const e = t["current-page"]?.data;
+  return e?.page ? e.page : e?.url ? e.url : t["browser-page"]?.data?.url;
+}
+function Et(t, e) {
+  return t === e ? !0 : JSON.stringify(t) === JSON.stringify(e);
+}
+function _t(t, e) {
+  const s = [];
+  for (const i of Object.keys(e))
+    i in t && (Et(t[i], e[i]) || s.push({
+      field: i,
+      from: t[i],
+      to: e[i]
+    }));
+  return s;
+}
+function bt(t, e) {
+  const s = St(e), i = At(e);
+  return {
+    changes: t && t.page === i ? _t(t.state, s) : [],
+    baseline: {
+      page: i,
+      state: s
+    }
+  };
+}
+function _(t) {
+  return t === null || typeof t != "object" ? JSON.stringify(t) ?? "null" : Array.isArray(t) ? `[${t.map(_).join(",")}]` : `{${Object.keys(t).sort().map((e) => `${JSON.stringify(e)}:${_(t[e])}`).join(",")}}`;
+}
+var kt = class {
+  constructor(t) {
+    this.callbacks = t, this.buffer = "", this.message = {}, this.toolCalls = [], this.sources = [], this.followUpReplies = [], this.isFirstChunk = !0, this.answerCompleteEmitted = !1, this.waitingClientEmitted = !1, this.firedClientFunctions = /* @__PURE__ */ new Set();
+  }
+  async processStream(t) {
+    if (!t.body) throw new k("Response has no body. The endpoint did not return a stream: check that `baseUrl` points at an AGO API and nothing (proxy, mock) strips the SSE body.", "stream_no_body");
+    const e = t.body.getReader(), s = new TextDecoder();
+    try {
+      for (; ; ) {
+        const { done: i, value: n } = await e.read();
+        if (i) break;
+        const o = s.decode(n, { stream: !0 });
+        this.buffer += o, this.processBuffer();
+      }
+      return this.buffer.trim() && this.processBuffer(), this.buildFinalMessage();
+    } catch (i) {
+      const n = i instanceof Error ? i : new k("Stream processing failed mid-flight. The connection may have dropped; retry the message.");
+      throw this.callbacks.onError?.(n), n;
+    } finally {
+      e.releaseLock();
+    }
+  }
+  processBuffer() {
+    const t = this.buffer.split(`
+
+`);
+    this.buffer = t.pop() || "";
+    for (const e of t) {
+      if (!e.trim()) continue;
+      const s = e.split(`
+`);
+      for (const i of s)
+        if (!i.startsWith(": ") && i.startsWith("data: ")) {
+          const n = i.slice(6);
+          try {
+            const o = JSON.parse(n);
+            this.handleChunk(o);
+          } catch (o) {
+            c.warn("Failed to parse SSE data:", n, o);
+          }
+        }
+    }
+  }
+  handleChunk(t) {
+    if (this.callbacks.onRawChunk?.(t), t.message_id && !this.message.id && (this.message.id = t.message_id), t.thread?.id && (this.message.conversationId = t.thread.id, this.isFirstChunk && this.message.id && (this.isFirstChunk = !1, this.callbacks.onStart?.({
+      conversationId: this.message.conversationId,
+      messageId: this.message.id
+    }))), t.content !== void 0 && (this.message.content = (this.message.content || "") + t.content, this.message.conversationId && this.message.id && this.callbacks.onChunk?.({
+      content: t.content,
+      conversationId: this.message.conversationId,
+      messageId: this.message.id
+    })), t.full_content !== void 0 && (this.message.content = t.full_content), t.status && (this.message.status = t.status), t.agent && (this.message.agent = {
+      id: t.agent.id,
+      name: t.agent.name,
+      displayName: t.agent.display_name
+    }), t.knowledge_sources && (this.sources = t.knowledge_sources.map((e) => {
+      const s = e.knowledge_document;
+      return {
+        id: s.id,
+        title: s.title,
+        url: s.use_external_link ? s.external_link_url : s.internal_link_url
+      };
+    })), t.type === "client_function" && t.function_name) {
+      const e = `${t.function_name}::${_(t.arguments ?? {})}`;
+      this.firedClientFunctions.has(e) || (this.firedClientFunctions.add(e), this.callbacks.onClientFunction?.({
+        invocationId: t.id || "",
+        functionName: t.function_name,
+        arguments: t.arguments || {},
+        conversationId: this.message.conversationId || ""
+      }));
+    }
+    if (t.tool_call_data && t.type && t.type !== "client_function") {
+      const e = this.parseToolCall(t);
+      this.callbacks.onToolCall?.(e);
+      const s = this.toolCalls.findIndex((i) => i.id === e.id);
+      s >= 0 ? this.toolCalls[s] = e : this.toolCalls.push(e);
+    }
+    t.follow_up_replies && (this.followUpReplies = t.follow_up_replies), this.message.status === "DONE" && !this.answerCompleteEmitted && this.message.id && (this.answerCompleteEmitted = !0, this.callbacks.onAnswerComplete?.(this.buildMessage())), this.message.status === "WAITING_CLIENT" && !this.waitingClientEmitted && this.message.id && (this.waitingClientEmitted = !0, this.callbacks.onWaitingClient?.({
+      conversationId: this.message.conversationId || "",
+      messageId: this.message.id,
+      waitingToolCallIds: t.waiting_tool_call_ids ?? []
+    }));
+  }
+  parseToolCall(t) {
+    return {
+      id: t.id || "",
+      type: t.type || "status_message",
+      status: t.status || "unknown",
+      toolName: t.tool_name || "",
+      toolDisplayName: t.tool_display_name,
+      message: t.message,
+      formSchema: t.form_schema,
+      data: t.data,
+      functionName: t.function_name,
+      arguments: t.arguments
+    };
+  }
+  buildMessage() {
+    return {
+      id: this.message.id || "",
+      conversationId: this.message.conversationId || "",
+      content: this.message.content || "",
+      role: "assistant",
+      status: this.message.status || "DONE",
+      agent: this.message.agent,
+      sources: this.sources.length > 0 ? this.sources : void 0,
+      toolCalls: this.toolCalls.length > 0 ? this.toolCalls : void 0,
+      followUpReplies: this.followUpReplies.length > 0 ? this.followUpReplies : void 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  buildFinalMessage() {
+    const t = this.buildMessage();
+    return t.status !== "WAITING_CLIENT" && this.callbacks.onComplete?.(t), t;
+  }
+};
+function Mt(t) {
+  const e = t.message.toLowerCase();
+  return e.includes("load failed") || e.includes("failed to fetch") || e.includes("network") || e.includes("abort");
+}
+var Rt = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp",
+  "image/bmp",
+  "image/tiff"
+]);
+function It(t) {
+  if (!t) return;
+  const e = typeof window < "u" && window.location ? window.location.href : "https://ago.local/";
+  try {
+    const s = new URL(t, e);
+    if (s.protocol === "http:" || s.protocol === "https:" || s.protocol === "blob:") return t;
+  } catch {
+  }
+}
+function Lt(t) {
+  return t.isSafeImage === !0 && typeof t.contentType == "string" && t.contentType.startsWith("image/") && It(t.url) !== void 0;
+}
+function jt(t) {
+  if (t == null || t < 0) return "";
+  if (t < 1024) return `${t} B`;
+  const e = t / 1024;
+  return e < 1024 ? `${e.toFixed(1)} KB` : `${(e / 1024).toFixed(1)} MB`;
+}
+function xt(t) {
+  return {
+    id: String(t.id ?? ""),
+    name: typeof t.name == "string" && t.name ? t.name : "file",
+    contentType: typeof t.content_type == "string" ? t.content_type : void 0,
+    fileSize: typeof t.file_size == "number" ? t.file_size : void 0,
+    url: typeof t.file_url == "string" ? t.file_url : void 0,
+    isSafeImage: t.is_safe_image === !0
+  };
+}
+function Bt(t) {
+  return t.map((e, s) => ({
+    id: `local-${s}-${e.name}`,
+    name: e.name,
+    contentType: e.type || void 0,
+    fileSize: e.size,
+    url: typeof URL < "u" && URL.createObjectURL ? URL.createObjectURL(e) : void 0,
+    isSafeImage: Rt.has(e.type)
+  }));
+}
+var Tt = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(t, e) {
+    this.handlers.has(t) || this.handlers.set(t, /* @__PURE__ */ new Set()), this.handlers.get(t).add(e);
+  }
+  off(t, e) {
+    const s = this.handlers.get(t);
+    s && s.delete(e);
+  }
+  emit(t, e) {
+    const s = this.handlers.get(t);
+    s && s.forEach((i) => {
+      try {
+        i(e);
+      } catch (n) {
+        console.error(`Error in event handler for ${String(t)}:`, n);
+      }
+    });
+  }
+  once(t, e) {
+    const s = ((i) => {
+      this.off(t, s), e(i);
+    });
+    this.on(t, s);
+  }
+  waitFor(t, e) {
+    return new Promise((s, i) => {
+      let n;
+      const o = ((a) => {
+        n && clearTimeout(n), s(a);
+      });
+      this.once(t, o), e?.timeout && (n = setTimeout(() => {
+        this.off(t, o), i(/* @__PURE__ */ new Error(`waitFor("${String(t)}") timed out after ${e.timeout}ms`));
+      }, e.timeout));
+    });
+  }
+  removeAllListeners(t) {
+    t ? this.handlers.delete(t) : this.handlers.clear();
+  }
+}, $ = '`baseUrl` is required, e.g. new AgoClient({ baseUrl: "https://YOUR-DOMAIN.api.useago.com" }). Try the live demo endpoint https://playground.api.useago.com. See docs/general/configuration.md#error-codes (config_missing_base_url).', Ft = /^[a-z][a-z0-9+.-]*:\/\//i, N = !1;
+function D(t, e = "AgoClient") {
+  if (typeof t != "object" || t === null) throw new g(`${e}: ${$}`, "config_missing_base_url");
+  const s = t.baseUrl;
+  if (typeof s != "string" || s.trim() === "") throw new g(`${e}: ${$}`, "config_missing_base_url");
+  !s.startsWith("/") && !Ft.test(s) && (N || (N = !0, console.warn(`[AGO] ${e}: \`baseUrl\` has no protocol and is not a relative path (config_suspect_base_url). Requests will fail: Node throws a URL parse error, browsers fetch it as a relative path. Use "https://..." (or a "/path" for a same-origin proxy).`)));
+}
+function $t(t) {
+  return t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function S(t) {
+  return t.split("/").filter((e) => e.startsWith(":")).map((e) => e.slice(1));
+}
+function Nt(t, e) {
+  const s = [];
+  return {
+    path: t.split("/").map((i) => {
+      if (!i.startsWith(":")) return i;
+      const n = i.slice(1), o = e[n];
+      return o == null || o === "" ? (s.push(n), i) : encodeURIComponent(String(o));
+    }).join("/"),
+    missing: s
+  };
+}
+function Dt(t, e) {
+  const s = e.find((n) => n.path === t);
+  if (s) return s;
+  const i = e.find((n) => {
+    if (!n.path.includes(":")) return !1;
+    const o = "^" + n.path.split("/").map((a) => a.startsWith(":") ? "[^/]+" : $t(a)).join("/") + "/?$";
+    return new RegExp(o).test(t);
+  });
+  return i || e.filter((n) => n.path !== "/" && t.startsWith(n.path)).sort((n, o) => o.path.length - n.path.length)[0];
+}
+var Pt = "activity:recent", Ot = "state:delta", Gt = class U {
+  constructor(e) {
+    this.lastSentPageState = null, this.warnedEmptyConversations = /* @__PURE__ */ new Set(), this.pendingResumes = /* @__PURE__ */ new Map(), this.pendingApprovals = /* @__PURE__ */ new Map(), this.resumeGate = null, this.proactive = null, D(e, "AgoClient"), this.config = e, this.activityLedger = new j(e.maxActivityEntries), this.httpClient = new K(e), this.functionRegistry = new J({ maxResultBytes: e.maxFunctionResultBytes }), this.contextRegistry = new wt(), this.eventEmitter = new Tt(), this.registerActivityContext(), e.debug && c.enable(), e.proactive && F(this, e.proactive), c.log("AgoClient initialized");
+  }
+  async sendMessage(e, s) {
+    const i = this.functionRegistry.getSchemas(), n = this.buildSendContext(), o = this.config.agent || this.config.defaultAgentId, a = this.resolveClientFunctionsMode(s), r = {
+      content: e,
+      conversation_id: s?.conversationId,
+      agent_id: s?.agentId || o
+    };
+    i.length > 0 && (r.client_functions = i, a === "pause" && (r.client_functions_mode = a)), n && (r.client_context = n), s?.hidden && (r.hidden = !0);
+    let l;
+    if (s?.files && s.files.length > 0) {
+      const h = new FormData();
+      h.append("content", e), s.conversationId && h.append("conversation_id", s.conversationId), (s.agentId || o) && h.append("agent_id", s.agentId || o || ""), i.length > 0 && (h.append("client_functions", JSON.stringify(i)), a === "pause" && h.append("client_functions_mode", a)), n && h.append("client_context", JSON.stringify(n)), s.hidden && h.append("hidden", "true");
+      for (const u of s.files) h.append("files", u);
+      l = await this.httpClient.postFormData("/api/sdk/v1/messages", h);
+    } else l = await this.httpClient.postStream("/api/sdk/v1/messages", r);
+    return this.processSSEResponse(l);
+  }
+  async processSSEResponse(e) {
+    let s = !1;
+    const i = await new kt({
+      onRawChunk: (n) => {
+        this.eventEmitter.emit("stream:message", n);
+      },
+      onStart: (n) => {
+        this.eventEmitter.emit("message:start", n);
+      },
+      onChunk: (n) => {
+        this.eventEmitter.emit("message:chunk", n);
+      },
+      onToolCall: (n) => {
+        this.eventEmitter.emit("toolCall:received", n), n.type === "form" && this.eventEmitter.emit("toolCall:form", n);
+      },
+      onClientFunction: async (n) => {
+        if (s = !0, this.eventEmitter.emit("function:invoke", n), this.recordAgentAction(n), n.invocationId && this.requiresApproval(n)) {
+          this.pendingApprovals.set(n.invocationId, n), this.eventEmitter.emit("function:awaiting-approval", n);
+          return;
+        }
+        await this.handleClientFunctionInvocation(n);
+      },
+      onAnswerComplete: (n) => {
+        this.eventEmitter.emit("message:answer-complete", n);
+      },
+      onWaitingClient: (n) => {
+        this.eventEmitter.emit("message:waiting-client", n), this.markResumeSignal(n.messageId, n.conversationId, "waitingConfirmed");
+      },
+      onComplete: (n) => {
+        this.eventEmitter.emit("message:complete", n);
+      },
+      onError: (n) => {
+        this.eventEmitter.emit("message:error", {
+          error: n.message,
+          code: n instanceof g ? n.code : void 0
+        });
+      }
+    }).processStream(e);
+    return i.status !== "WAITING_CLIENT" && this.maybeFlagEmptyReply(i, s), i;
+  }
+  resolveClientFunctionsMode(e) {
+    return e?.clientFunctionsMode ?? this.config.clientFunctionsMode ?? "pause";
+  }
+  registerResumeGate(e) {
+    return this.resumeGate = e, () => {
+      this.resumeGate === e && (this.resumeGate = null);
+    };
+  }
+  async continueMessage(e) {
+    const s = this.functionRegistry.getSchemas(), i = this.buildSendContext(), n = {};
+    s.length > 0 && (n.client_functions = s), i && (n.client_context = i);
+    const o = await this.httpClient.postStream(`/api/sdk/v1/messages/${e}/continue`, n);
+    return this.processSSEResponse(o);
+  }
+  markResumeSignal(e, s, i) {
+    if (!e) return;
+    const n = this.pendingResumes.get(e) ?? {
+      conversationId: s,
+      waitingConfirmed: !1,
+      resultsReady: !1,
+      started: !1
+    };
+    n[i] = !0, s && (n.conversationId = s), this.pendingResumes.set(e, n), !(!n.waitingConfirmed || !n.resultsReady || n.started) && (n.started = !0, this.runAutoResume(e, n.conversationId));
+  }
+  async runAutoResume(e, s) {
+    try {
+      this.resumeGate && await this.resumeGate({
+        conversationId: s,
+        messageId: e
+      });
+    } catch (i) {
+      c.warn("Resume gate threw; resuming anyway:", i);
+    }
+    this.pendingResumes.delete(e);
+    try {
+      await this.continueMessage(e);
+    } catch (i) {
+      c.warn("Auto-resume of paused turn failed:", i);
+    }
+  }
+  maybeFlagEmptyReply(e, s) {
+    e.status === "DONE" && (e.content ?? "").trim() === "" && !s && !(e.toolCalls && e.toolCalls.length > 0) && !(e.followUpReplies && e.followUpReplies.length > 0) && setTimeout(() => {
+      if (this.eventEmitter.emit("message:empty", {
+        conversationId: e.conversationId ?? "",
+        messageId: e.id ?? ""
+      }), this.config.warnOnEmptyReply === !1) return;
+      const i = e.conversationId || "(no conversation)";
+      if (this.warnedEmptyConversations.has(i)) return;
+      this.warnedEmptyConversations.add(i);
+      const n = this.config.agent || this.config.defaultAgentId;
+      e.id ? console.warn("[AGO] Reply completed with empty content. Possible causes: " + (n ? `the agent "${n}" may not exist for this tenant, ` : "an unknown `agent` slug, ") + "or the agent replied with no text. Listen for the `message:empty` event to handle this in your app; silence this warning with `warnOnEmptyReply: false`.") : console.warn("[AGO] The stream completed without any message data. Possible causes: " + (n ? `the agent "${n}" may not exist for this tenant, or ` : "") + "`baseUrl` does not point at an AGO endpoint that returns server-sent events. Listen for the `message:empty` event to handle this in your app; silence this warning with `warnOnEmptyReply: false`.");
+    }, 0);
+  }
+  async handleClientFunctionInvocation(e) {
+    let s, i;
+    try {
+      s = await this.functionRegistry.execute(e.functionName, e.arguments);
+    } catch (n) {
+      i = n instanceof Error ? n.message : "Unknown error", c.error("Client function execution failed:", n);
+    }
+    if (e.invocationId) try {
+      const n = await this.submitToolCallForm(e.invocationId, {
+        result: s,
+        error: i,
+        _type: "client_function_result"
+      });
+      n?.resume?.ready && this.markResumeSignal(n.resume.message_id, e.conversationId, "resultsReady");
+    } catch (n) {
+      c.error("Failed to submit function result:", n);
+    }
+    this.eventEmitter.emit("function:result", {
+      invocationId: e.invocationId,
+      result: s,
+      error: i
+    });
+  }
+  requiresApproval(e) {
+    const s = this.config.approvalPolicy;
+    if (s) try {
+      if (s(e)) return !0;
+    } catch (i) {
+      c.warn("approvalPolicy threw; not gating this call:", i);
+    }
+    return this.functionRegistry.get(e.functionName)?.requiresApproval === !0;
+  }
+  async approveFunction(e) {
+    const s = this.pendingApprovals.get(e);
+    s && (this.pendingApprovals.delete(e), await this.handleClientFunctionInvocation(s));
+  }
+  async rejectFunction(e) {
+    const s = this.pendingApprovals.get(e);
+    if (!s) return;
+    this.pendingApprovals.delete(e);
+    const i = {
+      approved: !1,
+      reason: "user_rejected"
+    };
+    try {
+      const n = await this.submitToolCallForm(e, {
+        result: i,
+        _type: "client_function_result"
+      });
+      n?.resume?.ready && this.markResumeSignal(n.resume.message_id, s.conversationId, "resultsReady");
+    } catch (n) {
+      c.error("Failed to submit function rejection:", n);
+    }
+    this.eventEmitter.emit("function:result", {
+      invocationId: e,
+      result: i
+    });
+  }
+  async getConversations() {
+    return (await this.httpClient.get("/api/sdk/v1/conversations")).items.map((e) => ({
+      id: e.id,
+      title: e.title,
+      lastMessageDate: new Date(e.last_message_date)
+    }));
+  }
+  async getConversation(e) {
+    const s = await this.httpClient.get(`/api/sdk/v1/conversations/${e}`), i = {
+      id: s.id,
+      title: s.title,
+      lastMessageDate: new Date(s.last_message_date),
+      messages: s.messages.map((n) => ({
+        id: n.id,
+        conversationId: s.id,
+        content: n.content,
+        role: n.role,
+        status: n.status,
+        createdAt: new Date(n.created_at),
+        hidden: n.hidden,
+        toolCalls: U.mapPersistedToolCalls(n.tool_call_data),
+        attachments: n.attachments && n.attachments.length > 0 ? n.attachments.map(xt) : void 0
+      }))
+    };
+    return this.eventEmitter.emit("conversation:loaded", i), i;
+  }
+  static mapPersistedToolCalls(e) {
+    if (!(!e || e.length === 0))
+      return e.map((s) => ({
+        id: String(s.id ?? ""),
+        type: s.type ?? "status_message",
+        status: String(s.status ?? "unknown"),
+        toolName: s.tool_name ?? "",
+        toolDisplayName: s.tool_display_name,
+        message: s.message,
+        formSchema: s.form_schema,
+        data: s.data,
+        functionName: s.function_name,
+        arguments: s.arguments
+      }));
+  }
+  async getMessages(e) {
+    return (await this.getConversation(e)).messages || [];
+  }
+  async resumePendingClientFunctions(e) {
+    const s = [...e.messages ?? []].reverse().find((r) => r.role === "assistant" && r.status === "WAITING_CLIENT");
+    if (!s) return null;
+    const i = (s.toolCalls ?? []).filter((r) => r.type === "client_function" && r.status === "waiting_input" && r.functionName), n = new Set(this.functionRegistry.getSchemas().map((r) => r.name)), o = i.filter((r) => !n.has(r.functionName));
+    if (o.length > 0)
+      return c.warn("Cannot resume paused turn: function(s) not registered on this page:", o.map((r) => r.functionName)), null;
+    let a = i.length === 0;
+    for (const r of i) {
+      const l = {
+        invocationId: r.id,
+        functionName: r.functionName,
+        arguments: r.arguments ?? {},
+        conversationId: e.id
+      };
+      if (this.requiresApproval(l)) {
+        this.pendingApprovals.set(r.id, l), this.markResumeSignal(s.id, e.id, "waitingConfirmed"), this.eventEmitter.emit("function:awaiting-approval", l), a = !1;
+        continue;
+      }
+      let h, u;
+      try {
+        h = await this.functionRegistry.execute(r.functionName, r.arguments ?? {});
+      } catch (d) {
+        u = d instanceof Error ? d.message : "Unknown error", c.error("Client function execution failed:", d);
+      }
+      a = (await this.submitToolCallForm(r.id, {
+        result: h,
+        error: u,
+        _type: "client_function_result"
+      }))?.resume?.ready ?? a;
+    }
+    return a ? this.continueMessage(s.id) : null;
+  }
+  async submitToolCallForm(e, s) {
+    return this.httpClient.post(`/api/sdk/v1/tool-calls/${e}/submit`, { formData: s });
+  }
+  async confirmToolCall(e) {
+    await this.httpClient.post(`/api/tool-calls/${e}/confirm/`);
+  }
+  async rejectToolCall(e) {
+    await this.httpClient.post(`/api/tool-calls/${e}/reject/`);
+  }
+  async getFormCollector(e) {
+    const s = await this.httpClient.get(`/api/sdk/v1/forms/${encodeURIComponent(e)}`);
+    return {
+      name: s.name,
+      description: s.description,
+      schema: s.schema,
+      submit: s.submit ?? void 0
+    };
+  }
+  async submitFormCollector(e, s) {
+    return this.httpClient.post("/api/sdk/v1/forms/submit", {
+      name: e,
+      values: s
+    });
+  }
+  async submitFeedback(e, s) {
+    await this.httpClient.post(`/api/sdk/v1/messages/${e}/feedback`, { rating: s });
+  }
+  registerFunction(e, s, i) {
+    typeof e == "object" ? this.functionRegistry.register(e) : this.functionRegistry.register(e, s, i);
+  }
+  register(e) {
+    if (Array.isArray(e)) for (const s of e) this.functionRegistry.register(s);
+    else this.functionRegistry.register(e);
+  }
+  unregisterFunction(e) {
+    return this.functionRegistry.unregister(e);
+  }
+  getRegisteredFunctions() {
+    return this.functionRegistry.getSchemas();
+  }
+  async executeClientFunction(e, s) {
+    return this.functionRegistry.execute(e, s);
+  }
+  registerNavigationFunction(e, s) {
+    const i = s.map((r) => r.name), n = s.map((r) => {
+      const l = S(r.path), h = l.length > 0 ? ` (requires ${l.map((u) => `"${u}"`).join(", ")})` : "";
+      return `- "${r.name}"${h}: ${r.description}`;
+    }).join(`
+`), o = /* @__PURE__ */ new Map();
+    for (const r of s) for (const l of S(r.path)) o.set(l, [...o.get(l) ?? [], r.name]);
+    const a = { page: {
+      type: "string",
+      description: "The page to navigate to",
+      enum: i
+    } };
+    for (const [r, l] of o) {
+      if (r === "page") {
+        c.error('registerNavigationFunction: a ":page" placeholder collides with the "page" argument and is ignored. Rename the placeholder.');
+        continue;
+      }
+      a[r] = {
+        type: "string",
+        description: `Value for ":${r}" in the page path. Required when page is ${l.map((h) => `"${h}"`).join(" or ")}.`
+      };
+    }
+    this.registerFunction("navigateToPage", async (r) => {
+      const l = r.page, h = s.find((f) => f.name === l);
+      if (!h) return {
+        success: !1,
+        error: `Unknown page: ${l}`
+      };
+      let u = {};
+      if (typeof r.params == "string") try {
+        u = JSON.parse(r.params);
+      } catch {
+      }
+      else r.params && typeof r.params == "object" && (u = r.params);
+      const d = {};
+      for (const f of S(h.path)) d[f] = r[f] ?? u[f];
+      const { path: m, missing: y } = Nt(h.path, d);
+      if (y.length > 0) {
+        const f = y.map((v) => `"${v}": "..."`).join(", ");
+        return {
+          success: !1,
+          error: `Page "${l}" needs ${y.map((v) => `"${v}"`).join(", ")}. Retry with { "page": "${l}", ${f} }.`
+        };
+      }
+      return e(m), {
+        success: !0,
+        navigatedTo: m
+      };
+    }, {
+      description: `Navigate the user to a page in the application. Available pages:
+${n}`,
+      parameters: {
+        type: "object",
+        properties: a,
+        required: ["page"]
+      }
+    }), this.addDynamicContext("current-page", () => {
+      if (typeof window > "u" || !window.location) return null;
+      const r = window.location.href, l = typeof document < "u" ? document.title : void 0, h = Dt(window.location.pathname, s), u = { url: r };
+      return h && (u.page = h.name), l && (u.title = l), {
+        name: "Current page",
+        description: "The page the user is currently viewing.",
+        data: u
+      };
+    });
+  }
+  unregisterNavigationFunction() {
+    this.unregisterFunction("navigateToPage"), this.removeDynamicContext("current-page");
+  }
+  registerPageStateFunction(e, s) {
+    const i = s?.functionName ?? "setPageState", n = new Map(e.map((a) => [a.name, a])), o = e.map((a) => `- "${a.name}": ${a.description}`).join(`
+`);
+    this.registerFunction(i, async (a) => {
+      const r = {};
+      for (const [l, h] of Object.entries(a)) {
+        if (h === void 0) continue;
+        const u = n.get(l);
+        u && (await u.set(h), r[l] = h);
+      }
+      return {
+        success: !0,
+        applied: r
+      };
+    }, {
+      description: `Change the state of the current page. Set ONLY the controls the user explicitly asked for; leave the others unset. Available controls:
+${o}`,
+      parameters: {
+        type: "object",
+        properties: Object.fromEntries(e.map((a) => [a.name, {
+          ...a.schema,
+          description: a.description
+        }]))
+      },
+      requiresApproval: s?.requiresApproval
+    }), this.addDynamicContext(`page-state:${i}`, () => {
+      const a = e.filter((l) => typeof l.get == "function");
+      if (a.length === 0) return null;
+      const r = {};
+      for (const l of a) r[l.name] = l.get();
+      return {
+        name: "Page state",
+        description: "Current, editable state of the page the user is viewing.",
+        data: r
+      };
+    });
+  }
+  unregisterPageStateFunction(e) {
+    const s = e ?? "setPageState";
+    this.unregisterFunction(s), this.removeDynamicContext(`page-state:${s}`);
+  }
+  setContext(e, s) {
+    this.contextRegistry.set(e, s), this.notifyContextChanged();
+  }
+  removeContext(e) {
+    const s = this.contextRegistry.remove(e);
+    return s && this.notifyContextChanged(), s;
+  }
+  addDynamicContext(e, s) {
+    this.contextRegistry.addDynamicProvider(e, s), this.notifyContextChanged();
+  }
+  removeDynamicContext(e) {
+    const s = this.contextRegistry.removeDynamicProvider(e);
+    return s && this.notifyContextChanged(), s;
+  }
+  notifyContextChanged() {
+    this.eventEmitter.emit("context:changed", this.contextRegistry.getSnapshot());
+  }
+  emitFormEvent(e, s) {
+    this.eventEmitter.emit(e, s);
+  }
+  emitProactiveEvent(e, s) {
+    this.eventEmitter.emit(e, s);
+  }
+  getHttp() {
+    return this.httpClient;
+  }
+  getConfiguredAgent() {
+    return this.config.agent || this.config.defaultAgentId;
+  }
+  enableAutoPageContext() {
+    this.addDynamicContext("browser-page", () => {
+      const e = typeof window < "u" ? window.location.href : void 0, s = typeof document < "u" ? document.title : void 0;
+      return !e && !s ? null : {
+        name: "Browser page",
+        description: "Current page the user is viewing",
+        data: {
+          url: e,
+          title: s
+        }
+      };
+    });
+  }
+  getContextSnapshot() {
+    return this.contextRegistry.getSnapshot();
+  }
+  buildSendContext() {
+    const e = this.contextRegistry.getSnapshot(), s = e?.entries ?? {}, { changes: i, baseline: n } = bt(this.lastSentPageState, s);
+    return this.lastSentPageState = n, i.length === 0 ? e : { entries: {
+      ...s,
+      [Ot]: {
+        name: "State changes",
+        description: "Fields in the page state that changed since your last message, as field: <old> -> <new>.",
+        data: { changes: i }
+      }
+    } };
+  }
+  recordActivity(e) {
+    this.addActivity(e);
+  }
+  getRecentActivity() {
+    return this.activityLedger.getRecent();
+  }
+  clearActivity() {
+    this.activityLedger.clear();
+  }
+  addActivity(e) {
+    const s = this.activityLedger.add(e);
+    this.eventEmitter.emit("activity:recorded", s);
+  }
+  recordAgentAction(e) {
+    const s = e.functionName, i = e.arguments;
+    let n, o;
+    if (s === "navigateToPage") {
+      const a = i?.page;
+      n = "agent.navigate", o = a ? `Agent navigated to "${String(a)}"` : "Agent navigated";
+    } else s === "setPageState" ? (n = "agent.page_state", o = "Agent changed the page state") : (n = `agent.${s}`, o = `Agent ran "${s}"`);
+    this.addActivity({
+      actor: "agent",
+      name: n,
+      summary: o,
+      ...i && Object.keys(i).length > 0 ? { data: { arguments: i } } : {}
+    });
+  }
+  registerActivityContext() {
+    this.contextRegistry.addDynamicProvider(Pt, () => {
+      const e = this.activityLedger.getRecent();
+      return e.length === 0 ? null : {
+        name: "Recent activity",
+        description: "Recent actions by the user and the agent in the app, oldest first. Use this to understand what just happened before this message.",
+        data: { events: e }
+      };
+    });
+  }
+  on(e, s) {
+    this.eventEmitter.on(e, s);
+  }
+  off(e, s) {
+    this.eventEmitter.off(e, s);
+  }
+  once(e, s) {
+    this.eventEmitter.once(e, s);
+  }
+  waitFor(e, s) {
+    return this.eventEmitter.waitFor(e, s);
+  }
+  updateConfig(e) {
+    const s = {};
+    for (const [n, o] of Object.entries(e)) o !== void 0 && (s[n] = o);
+    const i = {
+      ...this.config,
+      ...s
+    };
+    D(i, "AgoClient.updateConfig"), this.config = i, this.httpClient.updateConfig(s), s.debug !== void 0 && (s.debug ? c.enable() : c.disable()), s.maxFunctionResultBytes !== void 0 && this.functionRegistry.setDefaultMaxResultBytes(s.maxFunctionResultBytes);
+  }
+  destroy() {
+    this.proactive?.destroy(), this.proactive = null, this.eventEmitter.removeAllListeners(), this.functionRegistry.clear(), this.contextRegistry.clear(), this.pendingResumes.clear(), this.pendingApprovals.clear(), this.resumeGate = null, c.log("AgoClient destroyed");
+  }
+  reviveAfterDestroy() {
+    this.registerActivityContext(), this.config.proactive && !this.proactive && F(this, this.config.proactive);
+  }
+};
+export {
+  k as C,
+  w as S,
+  Ut as T,
+  J as _,
+  Lt as a,
+  g as b,
+  kt as c,
+  F as d,
+  ct as f,
+  et as g,
+  st as h,
+  Bt as i,
+  Mt as l,
+  O as m,
+  D as n,
+  jt as o,
+  lt as p,
+  Tt as r,
+  It as s,
+  Gt as t,
+  wt as u,
+  c as v,
+  j as w,
+  R as x,
+  p as y
+};