@aintela/chat 0.2.15

package/dist/httpArtifactService-BAR60Gu1.js

@@ -0,0 +1,1802 @@
+var et = Object.defineProperty;
+var dt = (E, t, e) => t in E ? et(E, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : E[t] = e;
+var g = (E, t) => et(E, "name", { value: t, configurable: !0 });
+var a = (E, t, e) => dt(E, typeof t != "symbol" ? t + "" : t, e);
+import { d as _, t as gt, E as T, k as ft, j as mt, q as pt, C as L } from "./environmentUtils-BaKw5_VD.js";
+import { I as A, S as lt, g as St, L as wt, P as F, b as Tt, e as yt, T as It, c as Ct } from "./serializer-DyHZxlAG.js";
+import { unified as vt } from "unified";
+import Et from "remark-parse";
+import { toMarkdown as Mt } from "mdast-util-to-markdown";
+import { format as Ot } from "date-fns";
+import Dt from "lodash";
+import { P as At, C as P } from "./Prompt-DZb7OaPp.js";
+const S = {
+  ARTIFACTS: "envision-artifacts",
+  SECTIONS: "envision-sections",
+  PROMPTS: "envision-prompts"
+}, k = [
+  {
+    id: "dashboards",
+    name: "Dashboards",
+    isDefault: !0,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    iconType: "dashboard"
+  },
+  {
+    id: "charts",
+    name: "Chart",
+    isDefault: !0,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    iconType: "chart"
+  },
+  {
+    id: "data-analytics",
+    name: "Data Analytics",
+    isDefault: !0,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    iconType: "folder"
+  }
+], W = class W {
+  constructor() {
+    a(this, "onPromptCreated", /* @__PURE__ */ g(() => {
+    }, "onPromptCreated"));
+  }
+  getItem(t) {
+    return localStorage.getItem(t);
+  }
+  setItem(t, e) {
+    localStorage.setItem(t, e);
+  }
+  removeItem(t) {
+    localStorage.removeItem(t);
+  }
+  initializeStorage() {
+    try {
+      const t = localStorage.getItem(S.SECTIONS);
+      if (!t)
+        localStorage.setItem(S.SECTIONS, JSON.stringify(k));
+      else {
+        const s = JSON.parse(t);
+        if (k.some(
+          (i) => !s.find((r) => r.id === i.id)
+        )) {
+          const i = [...s];
+          k.forEach((r) => {
+            s.find((l) => l.id === r.id) || i.push(r);
+          }), localStorage.setItem(S.SECTIONS, JSON.stringify(i));
+        }
+      }
+      const e = localStorage.getItem(S.ARTIFACTS);
+      if (e) {
+        const s = JSON.parse(e);
+        let n = !1;
+        const i = s.map((r) => {
+          if (!r.sectionId) {
+            n = !0;
+            let l = "data-analytics";
+            return r.type === _.Dashboard ? l = "dashboards" : r.type === _.Chart && (l = "charts"), {
+              ...r,
+              sectionId: l
+            };
+          }
+          return r;
+        });
+        n && localStorage.setItem(S.ARTIFACTS, JSON.stringify(i));
+      }
+    } catch (t) {
+      console.error("Error initializing storage:", t);
+    }
+  }
+  getSections() {
+    try {
+      const t = localStorage.getItem(S.SECTIONS);
+      return t ? JSON.parse(t) : k;
+    } catch (t) {
+      return console.error("Error loading sections:", t), k;
+    }
+  }
+  getArtifacts() {
+    try {
+      const t = localStorage.getItem(S.ARTIFACTS);
+      return t ? JSON.parse(t) : [];
+    } catch (t) {
+      return console.error("Error loading artifacts:", t), [];
+    }
+  }
+  createSection(t, e = "folder") {
+    const s = {
+      id: crypto.randomUUID(),
+      name: t,
+      isDefault: !1,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      iconType: e
+    }, n = this.getSections();
+    return n.push(s), localStorage.setItem(S.SECTIONS, JSON.stringify(n)), s;
+  }
+  updateSection(t, e) {
+    const s = this.getSections(), n = s.findIndex((i) => i.id === t);
+    n >= 0 && (s[n] = { ...s[n], ...e }, localStorage.setItem(S.SECTIONS, JSON.stringify(s)));
+  }
+  deleteSection(t) {
+    const e = this.getSections(), s = e.find((n) => n.id === t);
+    if (s && !s.isDefault) {
+      const n = this.getArtifacts(), i = s.iconType === "dashboard" ? "dashboards" : s.iconType === "chart" ? "charts" : "data-analytics", r = n.map((c) => c.sectionId === t ? { ...c, sectionId: i } : c);
+      localStorage.setItem(S.ARTIFACTS, JSON.stringify(r));
+      const l = e.filter((c) => c.id !== t);
+      localStorage.setItem(S.SECTIONS, JSON.stringify(l));
+    }
+  }
+  storeArtifact(t) {
+    try {
+      const e = this.getArtifacts(), s = e.findIndex((n) => n.id === t.id);
+      if (s >= 0)
+        e[s] = t;
+      else {
+        let n = "data-analytics";
+        t.type === _.Dashboard ? n = "dashboards" : t.type === _.Chart && (n = "charts");
+        const i = {
+          ...t,
+          created: t.created || (/* @__PURE__ */ new Date()).toISOString(),
+          sectionId: t.sectionId || n
+        };
+        e.push(i);
+      }
+      localStorage.setItem(S.ARTIFACTS, JSON.stringify(e));
+    } catch (e) {
+      console.error("Error storing artifact:", e);
+    }
+  }
+  moveArtifact(t, e) {
+    const s = this.getArtifacts(), n = s.findIndex((i) => i.id === t);
+    n >= 0 && (s[n] = { ...s[n], sectionId: e }, localStorage.setItem(S.ARTIFACTS, JSON.stringify(s)));
+  }
+  deleteArtifact(t) {
+    const s = this.getArtifacts().filter((n) => n.id !== t);
+    localStorage.setItem(S.ARTIFACTS, JSON.stringify(s));
+  }
+  updateArtifact(t, e) {
+    const s = this.getArtifacts(), n = s.findIndex((i) => i.id === t);
+    n >= 0 && (s[n] = { ...s[n], ...e }, localStorage.setItem(S.ARTIFACTS, JSON.stringify(s)));
+  }
+  getArtifactsBySection(t) {
+    return this.getArtifacts().filter((s) => s.sectionId === t);
+  }
+  // Prompt management methods
+  getPrompts() {
+    try {
+      const t = localStorage.getItem(S.PROMPTS);
+      return t ? JSON.parse(t).sort((s, n) => new Date(n.created).getTime() - new Date(s.created).getTime()) : [];
+    } catch (t) {
+      return console.error("Error loading prompts:", t), [];
+    }
+  }
+  storePrompt(t) {
+    try {
+      const e = this.getPrompts();
+      e.length > 0 && e[0].promptText === t.promptText && (e[0].created = t.created, e[0].id = t.id), e.unshift(t);
+      const s = e.slice(0, 50);
+      localStorage.setItem(S.PROMPTS, JSON.stringify(s));
+    } catch (e) {
+      console.error("Error storing prompt:", e);
+    }
+  }
+  deletePrompt(t) {
+    try {
+      const s = this.getPrompts().filter((n) => n.id !== t);
+      localStorage.setItem(S.PROMPTS, JSON.stringify(s));
+    } catch (e) {
+      console.error("Error deleting prompt:", e);
+    }
+  }
+  clearAllPrompts() {
+    try {
+      localStorage.removeItem(S.PROMPTS);
+    } catch (t) {
+      console.error("Error clearing prompts:", t);
+    }
+  }
+};
+g(W, "LocalStorageService");
+let st = W;
+const Kt = /* @__PURE__ */ g((E) => {
+  const t = E.getPrompts(), e = t.length;
+  if (e > 0) {
+    const s = t[0].promptText, n = t[t.length - 1].promptText, i = t[0].created;
+    return { promptState: e + "_" + s + "_" + n + "_" + i };
+  } else
+    return { promptState: "0" };
+}, "usePromptState"), J = class J {
+  constructor() {
+    a(this, "activityLost", "activityLost");
+    a(this, "artifactGenerated", "artifactGenerated");
+    a(this, "artifactSelected", "artifactSelected");
+    a(this, "artifactDeleted", "artifactDeleted");
+    a(this, "gatewayMessage", "gatewayMessage");
+    a(this, "gatewayTurnComplete", "gatewayTurnComplete");
+    a(this, "gatewayStreamError", "gatewayStreamError");
+    a(this, "gatewayTurnOpen", "gatewayTurnOpen");
+    a(this, "sessionCreated", "sessionCreated");
+    a(this, "sessionUpdated", "sessionUpdated");
+    a(this, "gatewayFunctionResponse", "gatewayFunctionResponse");
+    a(this, "uiUnsavedPopoverToggle", "uiUnsavedPopoverToggle");
+    a(this, "artifactsStorageUpdated", "artifactsStorageUpdated");
+    a(this, "gatewayStreamEnded", "gatewayStreamEnded");
+    a(this, "streamNewChunk", "streamNewChunk");
+    a(this, "gatewayEndMessageData", "gatewayEndMessageData");
+    a(this, "connectionStateChange", "connectionStateChange");
+    a(this, "onMessageSent", "onMessageSent");
+    a(this, "onMessageError", "onMessageError");
+    a(this, "onToolEvent", "onToolEvent");
+    a(this, "gatewayFirstToken", "gatewayFirstToken");
+  }
+};
+g(J, "EventTypes");
+let U = J;
+const o = new U(), q = class q {
+  constructor() {
+    a(this, "listeners", {});
+    a(this, "listenersCount", {});
+  }
+  callListeners(t, ...e) {
+    const s = this.listeners[t];
+    if (this.listenersCount[t] = this.listenersCount[t] + 1, s) {
+      const n = s.map((i) => i(...e));
+      Promise.all(n).catch((i) => {
+        console.error(`Lost error in one of the listeners of the event: ${t}, listeners: ${s.length}, error: ${i}`, s);
+      });
+    }
+  }
+  addListener(t, e) {
+    this.listeners[t] || (this.listeners[t] = [], this.listenersCount[t] = 0), this.listeners[t].push(e);
+  }
+  getEventState(t) {
+    return this.listenersCount[t];
+  }
+  activityOnLost(t) {
+    const e = o.activityLost;
+    this.addListener(e, t);
+  }
+  activityEmitLost() {
+    this.callListeners(o.activityLost);
+  }
+  /* typed artifact listeners */
+  artifactOnGenerated(t) {
+    const e = o.artifactGenerated;
+    this.addListener(e, t);
+  }
+  artifactEmitGenerated(t) {
+    this.callListeners(o.artifactGenerated, t);
+  }
+  artifactOffGenerated(t) {
+    const e = o.artifactGenerated;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  artifactOnSelected(t) {
+    const e = o.artifactSelected;
+    this.addListener(e, t);
+  }
+  artifactEmitSelected(t) {
+    this.callListeners(o.artifactSelected, t);
+  }
+  artifactOffSelected(t) {
+    const e = o.artifactSelected;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  artifactOnDeleted(t) {
+    const e = o.artifactDeleted;
+    this.addListener(e, t);
+  }
+  artifactEmitDeleted(t) {
+    this.callListeners(o.artifactDeleted, t);
+  }
+  artifactOffDeleted(t) {
+    const e = o.artifactDeleted;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnMessage(t) {
+    const e = o.gatewayMessage;
+    this.addListener(e, t);
+  }
+  gatewayOnTurnComplete(t) {
+    const e = o.gatewayTurnComplete;
+    this.addListener(e, t);
+  }
+  gatewayOnTurnOpen(t) {
+    const e = o.gatewayTurnOpen;
+    this.addListener(e, t);
+  }
+  gatewayOnStreamError(t) {
+    const e = o.gatewayStreamError;
+    this.addListener(e, t);
+  }
+  gatewayOnStreamEnded(t) {
+    const e = o.gatewayStreamEnded;
+    this.addListener(e, t);
+  }
+  gatewayOffStreamEnded(t) {
+    const e = o.gatewayStreamEnded;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayEmitStreamEnded(t, e) {
+    this.callListeners(o.gatewayStreamEnded, t, e);
+  }
+  gatewayEmitMessage(t, e = null) {
+    this.callListeners(o.gatewayMessage, t, e);
+  }
+  gatewayEmitTurnComplete(t, e) {
+    this.callListeners(o.gatewayTurnComplete, t, e);
+  }
+  gatewayEmitStreamError(t) {
+    this.callListeners(o.gatewayStreamError, t);
+  }
+  gatewayEmitTurnOpen(t) {
+    this.callListeners(o.gatewayTurnOpen, t);
+  }
+  gatewayOffMessage(t) {
+    const e = o.gatewayMessage;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOffTurnComplete(t) {
+    const e = o.gatewayTurnComplete;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOffTurnOpen(t) {
+    const e = o.gatewayTurnOpen;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOffStreamError(t) {
+    const e = o.gatewayStreamError;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  sessionOnCreated(t) {
+    const e = o.sessionCreated;
+    this.addListener(e, t);
+  }
+  chatOnMessageSent(t) {
+    const e = o.onMessageSent;
+    this.addListener(e, t);
+  }
+  chatOffMessageSent(t) {
+    const e = o.onMessageSent;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  ChatEmitMessageSent(t, e) {
+    this.callListeners(o.onMessageSent, t, e);
+  }
+  chatOnMessageError(t) {
+    const e = o.onMessageError;
+    this.addListener(e, t);
+  }
+  chatOffMessageError(t) {
+    const e = o.onMessageError;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  ChatEmitMessageError(t) {
+    this.callListeners(o.onMessageError, t);
+  }
+  sessionOnUpdated(t) {
+    const e = o.sessionUpdated;
+    this.addListener(e, t);
+  }
+  sessionEmitCreated(t) {
+    this.callListeners(o.sessionCreated, t);
+  }
+  sessionEmitUpdated(t) {
+    this.callListeners(o.sessionUpdated, t);
+  }
+  sessionOffCreated(t) {
+    const e = o.sessionCreated;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  sessionOffUpdated(t) {
+    const e = o.sessionUpdated;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayEmitFunctionResponse(t) {
+    this.callListeners(o.gatewayFunctionResponse, t);
+  }
+  gatewayOffFunctionResponse(t) {
+    const e = o.gatewayFunctionResponse;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnFunctionResponse(t) {
+    const e = o.gatewayFunctionResponse;
+    this.addListener(e, t);
+  }
+  // UI events
+  uiOnUnsavedPopoverToggle(t) {
+    const e = o.uiUnsavedPopoverToggle;
+    this.addListener(e, t);
+  }
+  uiEmitUnsavedPopoverToggle(t) {
+    this.callListeners(o.uiUnsavedPopoverToggle, t);
+  }
+  uiOffUnsavedPopoverToggle(t) {
+    const e = o.uiUnsavedPopoverToggle;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  // Artifacts storage update events
+  artifactsOnStorageUpdated(t) {
+    const e = o.artifactsStorageUpdated;
+    this.addListener(e, t);
+  }
+  artifactsEmitStorageUpdated() {
+    this.callListeners(o.artifactsStorageUpdated);
+  }
+  artifactsOffStorageUpdated(t) {
+    const e = o.artifactsStorageUpdated;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  streamOnNewChunk(t) {
+    const e = o.streamNewChunk;
+    this.addListener(e, t);
+  }
+  streamEmitNewChunk(t) {
+    this.callListeners(o.streamNewChunk, t);
+  }
+  streamOffNewChunk(t) {
+    const e = o.streamNewChunk;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnEndMessageData(t) {
+    const e = o.gatewayEndMessageData;
+    this.addListener(e, t);
+  }
+  gatewayEmitEndMessageData(t) {
+    this.callListeners(o.gatewayEndMessageData, t);
+  }
+  gatewayOffEndMessageData(t) {
+    const e = o.gatewayEndMessageData;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnConnectionStateChange(t) {
+    const e = o.connectionStateChange;
+    this.addListener(e, t);
+  }
+  gatewayEmitConnectionStateChange(t) {
+    this.callListeners(o.connectionStateChange, t);
+  }
+  gatewayOffConnectionStateChange(t) {
+    const e = o.connectionStateChange;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnToolEvent(t) {
+    const e = o.onToolEvent;
+    this.addListener(e, t);
+  }
+  gatewayEmitToolEvent(t, e, s) {
+    this.callListeners(o.onToolEvent, t, e, s);
+  }
+  gatewayOffToolEvent(t) {
+    const e = o.onToolEvent;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+  gatewayOnFirstToken(t) {
+    const e = o.gatewayFirstToken;
+    this.addListener(e, t);
+  }
+  gatewayEmitFirstToken(t) {
+    this.callListeners(o.gatewayFirstToken, t);
+  }
+  gatewayOffFirstToken(t) {
+    const e = o.gatewayFirstToken;
+    this.listeners[e] && (this.listeners[e] = this.listeners[e].filter((s) => s !== t));
+  }
+};
+g(q, "EventBusService");
+let x = q;
+const G = class G extends x {
+  constructor() {
+    super();
+  }
+  gatewayEmitConnectionStateChange(t) {
+    console.log("MockEventBusService.gatewayEmitConnectionStateChange");
+  }
+  gatewayEmitMessage(t, e) {
+    gt() ? process.stdout.write(`M${t.version}, `) : console.log("MockEventBusService.gatewayEmitMessage");
+  }
+  gatewayEmitTurnComplete(t, e) {
+    console.log("MockEventBusService.gatewayEmitTurnComplete");
+  }
+  gatewayEmitTurnOpen(t) {
+    console.log("MockEventBusService.gatewayEmitTurnOpen");
+  }
+  gatewayEmitFunctionResponse(t) {
+    console.log("MockEventBusService.gatewayEmitFunctionResponse");
+  }
+  gatewayOnFunctionResponse(t) {
+    console.log("MockEventBusService.gatewayOnFunctionResponse", t);
+  }
+  gatewayOffFunctionResponse(t) {
+    console.log("MockEventBusService.gatewayOffFunctionResponse", t);
+  }
+};
+g(G, "MockEventBusService");
+let nt = G;
+const ht = {
+  inline: "inline",
+  block: "block"
+}, H = class H {
+  constructor() {
+    a(this, "parts", []);
+    a(this, "isLastGroup", !1);
+    a(this, "hasThoughts", !1);
+    a(this, "lastWithThoughts", !1);
+    a(this, "type", ht.inline);
+  }
+};
+g(H, "InteractionPartGroup");
+let R = H;
+const K = class K {
+  constructor(t, e) {
+    a(this, "interaction");
+    a(this, "eventBusService");
+    a(this, "parseTextIntoParts", /* @__PURE__ */ g((t) => {
+      if (!t || t.trim().length == 0) return [];
+      const e = vt().use(Et).parse(t), s = [];
+      let n = null;
+      for (const i of e.children)
+        i.type === "code" ? (n && (s.push(n), n = null), i.lang === "htmlCanvas" && s.push(`
+\`\`\`liveTsx
+${i.value}
+\`\`\`
+`)) : (n || (n = ""), n += Mt(i));
+      return n && s.push(n), s;
+    }, "parseTextIntoParts"));
+    this.interaction = t, this.eventBusService = e;
+  }
+  expandSubParts(t, e) {
+    const s = this.parseTextIntoParts(t), n = [];
+    let i = 0;
+    for (const r of s) {
+      const l = A.fromText(r);
+      l.id = i + "_" + e, n.push(l), i++;
+    }
+    return n;
+  }
+  groupPartsByDisplayType(t, e = !0, s = !1) {
+    var l;
+    const n = [];
+    let i = new R();
+    for (let c = 0; c < t.length; c++) {
+      const u = t[c];
+      let h = !(((l = u.functionDetails) == null ? void 0 : l.isUi) ?? !1) && u.eventType !== T.Text && u.eventType !== T.Thought && (u.eventType === T.FunctionCall || u.eventType === T.PartialFunctionCall || u.eventType === T.FunctionResponse) && c < t.length - 1;
+      !e && h && !s || (h ? (u.eventType == T.Thought && (i.hasThoughts = !0), i.parts.push(u), i.isLastGroup = c === t.length - 1) : (i.parts.length > 0 && (n.push(i), i = new R()), n.push({
+        type: ht.block,
+        parts: [u],
+        isLastGroup: c === t.length - 1,
+        hasThoughts: !1,
+        lastWithThoughts: !1
+      })));
+    }
+    i.parts.length > 0 && n.push(i);
+    const r = n.filter((c) => c.hasThoughts);
+    return r.length > 0 && (r[r.length - 1].lastWithThoughts = !0), n;
+  }
+  isFunctionCall(t) {
+    return t == T.FunctionCall || t == T.PartialFunctionCall;
+  }
+  isFunctionResponse(t) {
+    return t == T.FunctionResponse;
+  }
+  // Computes the next interaction from a server event. Pure with respect to
+  // `prev` — no part or array on the prior tree is mutated; modified entities
+  // are cloned. The service field `this.interaction` is replaced with the
+  // new tree as the last step, so snapshots already handed out to throttled
+  // subscribers can't diverge from the live state.
+  merge(t) {
+    var Q, X, Z, V;
+    const e = this.interaction, s = [], n = [], i = A.FlatParts(t == null ? void 0 : t.parts), r = e.parts[e.parts.length - 1] ?? null;
+    let l = !1;
+    i && (l = !r || i.mustPush || i.mustPush === !1 && (i.eventType !== (r == null ? void 0 : r.eventType) || ((Q = i == null ? void 0 : i.functionDetails) == null ? void 0 : Q.id) !== ((X = r.functionDetails) == null ? void 0 : X.id)));
+    let c = e.parts, u = e.functionMap ?? /* @__PURE__ */ new Map(), d = !e.functionMap;
+    const h = /* @__PURE__ */ g(() => {
+      d || (u = new Map(u), d = !0);
+    }, "cloneFunctionMap"), C = /* @__PURE__ */ g(() => {
+      c === e.parts && (c = e.parts.slice());
+    }, "clonePartsIfShared");
+    let m = !1;
+    if (l && i) {
+      const p = this.isFunctionCall(i.eventType) || this.isFunctionResponse(i.eventType), y = p ? (Z = i.functionDetails) == null ? void 0 : Z.id : void 0;
+      p && !y && console.error("Got isCall or isResponse without a callId", i);
+      const M = y ? u.get(y) : void 0;
+      if (M && y && i.functionDetails) {
+        const v = c.findIndex((ut) => {
+          var tt;
+          return ((tt = ut.functionDetails) == null ? void 0 : tt.id) === y;
+        }), I = v > -1 ? c[v] : M, N = {
+          ...I,
+          eventType: i.eventType,
+          functionDetails: {
+            id: I.functionDetails.id,
+            name: i.functionDetails.name ?? I.functionDetails.name,
+            // Take the parsed args from the incoming event when
+            // present (the full FunctionCall carries them), fall
+            // back to what was already on the part. Previously
+            // this was `current.functionDetails!.args`
+            // unconditionally, which silently dropped the parsed
+            // args off every full FunctionCall fold because the
+            // PartialFunctionCall stream only accumulates raw
+            // JSON in `.text` — `.args` stayed undefined.
+            args: i.functionDetails.args ?? I.functionDetails.args,
+            response: i.functionDetails.response,
+            status: i.functionDetails.status ?? "Composing",
+            start: i.functionDetails.start ?? I.functionDetails.start,
+            end: i.functionDetails.end ?? I.functionDetails.end,
+            // true-wins: a UI call has multiple reps (streaming part with isUi, the
+            // persisted FunctionCall, the result) and they interleave. `??` let a later
+            // `false`/`undefined` rep clobber an earlier `true`; OR-ing keeps it sticky.
+            isUi: i.functionDetails.isUi === !0 || I.functionDetails.isUi === !0,
+            // Keep the call's friendly args summary when the result event (which has none) folds in.
+            argsDescription: i.functionDetails.argsDescription ?? I.functionDetails.argsDescription,
+            // The tool's client-only payload rides the RESULT event; keep it sticky so a
+            // later rep without one can't clobber it. This is what a uiTool renderer reads.
+            clientOutput: i.functionDetails.clientOutput ?? I.functionDetails.clientOutput
+          }
+        };
+        h(), u.set(y, N), N.eventType === T.FunctionResponse && this.eventBusService.gatewayEmitFunctionResponse(N.functionDetails), s.push(N), v > -1 && (C(), c[v] = N);
+      } else {
+        if (y && i.functionDetails && !M && (h(), u.set(y, i)), r && r.textAppendable) {
+          const I = {
+            ...r,
+            ended: /* @__PURE__ */ new Date(),
+            isStillWriting: !1
+          };
+          C(), c[c.length - 1] = I, s.push(I);
+        }
+        const v = {
+          ...i,
+          id: c.length + 1 + "-" + e.interactionId,
+          isStillWriting: i.textAppendable,
+          partial: t.partial
+        };
+        (V = v.functionDetails) != null && V.silent || s.push(v), c = [...c, v], m = !0;
+      }
+    }
+    let f = c[c.length - 1] ?? null;
+    if (f && i && i.textAppendable) {
+      const p = {
+        ...f,
+        partial: t.partial,
+        textDetails: f.textDetails ? { ...f.textDetails } : { version: 0 }
+      };
+      let y = !1;
+      if (t.partial) {
+        try {
+          p.textDetails.version++, m || (p.text = (f.text ?? "") + (i.text ?? ""));
+        } catch (M) {
+          console.error("Error here", M.toString());
+        }
+        p.textLastChunk = i.text ?? "", p.isStillWriting = !0, y = !0, i.thoughtDetails && p.thoughtDetails && i.thoughtDetails.text !== p.thoughtDetails.text && (p.thoughtDetails = {
+          ...p.thoughtDetails,
+          text: p.thoughtDetails.text + i.thoughtDetails.text
+        }, p.thoughtLastChunk = i.thoughtDetails.text);
+      } else
+        p.isStillWriting = !1, p.text = i.text ?? "", p.textDetails.version++, i.thoughtDetails && (p.thoughtDetails = {
+          ...i.thoughtDetails,
+          text: i.thoughtDetails.text.trim()
+        }), y = !l;
+      C(), c[c.length - 1] = p, f = p, y && s.push(p);
+    }
+    let w = e.artifactData ?? [];
+    if (t.llmArtifacts && t.llmArtifacts.length > 0) {
+      let p = !1;
+      for (const y of t.llmArtifacts) {
+        const M = y.toArtifact();
+        p || (w = w.slice(), p = !0);
+        const v = w.findIndex((I) => I.id === M.id);
+        v === -1 ? w.push(M) : w[v] = M;
+      }
+    }
+    const O = {
+      ...e,
+      version: e.version + 1,
+      parts: c,
+      artifactData: w,
+      functionMap: u,
+      turn_complete: t.turn_complete,
+      partial: t.partial,
+      asyncFinalResponse: t.asyncFinalResponse
+    };
+    return this.interaction = O, {
+      updatedInteraction: O,
+      updatedParts: s,
+      newArtifacts: n,
+      mainBranch: O,
+      analyticsBranch: null,
+      analyticsBranchPartsChanged: null,
+      mainBranchPartsChanged: s
+    };
+  }
+};
+g(K, "InteractionService");
+let b = K;
+const Nt = 1200 * 1e3, D = class D {
+  constructor(t, e, s, n, i, r, l, c, u, d = mt.Interactive) {
+    a(this, "base_production_url", ft() ?? "https://agent.tripapi.com.br");
+    a(this, "base_url_local", "http://localagent:8000");
+    a(this, "base_url");
+    a(this, "isLocal", !1);
+    a(this, "msg_order", 0);
+    a(this, "lastPing", /* @__PURE__ */ new Date());
+    a(this, "interactionsMap", /* @__PURE__ */ new Map());
+    a(this, "interactionsServiceMap", /* @__PURE__ */ new Map());
+    a(this, "user");
+    a(this, "config");
+    a(this, "currentIS", null);
+    a(this, "server_session_id");
+    a(this, "model_session_id");
+    a(this, "runMode");
+    a(this, "sessionState");
+    a(this, "storageService");
+    a(this, "notificationPort");
+    a(this, "interactionCallIds", /* @__PURE__ */ new Map());
+    a(this, "rawJwt");
+    a(this, "sessionId");
+    a(this, "isInited", !1);
+    //Define all SSEServer methods here, use from SSEServer.ts
+    a(this, "eventBusService");
+    a(this, "artifactService");
+    a(this, "onTurnOpen", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnTurnOpen(t);
+    }, "onTurnOpen"));
+    a(this, "offTurnOpen", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffTurnOpen(t);
+    }, "offTurnOpen"));
+    a(this, "onTurnComplete", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnTurnComplete(t);
+    }, "onTurnComplete"));
+    a(this, "offTurnComplete", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffTurnComplete(t);
+    }, "offTurnComplete"));
+    a(this, "onStreamError", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnStreamError(t);
+    }, "onStreamError"));
+    a(this, "offStreamError", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffStreamError(t);
+    }, "offStreamError"));
+    a(this, "onStreamEnded", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnStreamEnded(t);
+    }, "onStreamEnded"));
+    a(this, "offStreamEnded", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffStreamEnded(t);
+    }, "offStreamEnded"));
+    a(this, "onMessage", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnMessage(t);
+    }, "onMessage"));
+    a(this, "offMessage", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffMessage(t);
+    }, "offMessage"));
+    a(this, "onFirstToken", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnFirstToken(t);
+    }, "onFirstToken"));
+    a(this, "offFirstToken", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffFirstToken(t);
+    }, "offFirstToken"));
+    a(this, "onFunctionResponse", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOnFunctionResponse(t);
+    }, "onFunctionResponse"));
+    a(this, "offFunctionResponse", /* @__PURE__ */ g((t) => {
+      this.eventBusService.gatewayOffFunctionResponse(t);
+    }, "offFunctionResponse"));
+    a(this, "toolSessionId", null);
+    a(this, "pendingCurrentMessage", null);
+    a(this, "lastCurrentMessageUpdate", 0);
+    a(this, "runningRequests", /* @__PURE__ */ new Map());
+    a(this, "lastToolInteraction", "");
+    a(this, "subAgentInteractions", /* @__PURE__ */ new Map());
+    a(this, "subAgentInteractionServices", /* @__PURE__ */ new Map());
+    a(this, "lastThorttledTimeout", null);
+    a(this, "lastPingStatus", !1);
+    this.user = t, this.config = i, this.rawJwt = t.access_token, this.base_url = n, this.eventBusService = e, this.sessionId = u, this.runMode = d, this.artifactService = s, this.sessionState = r.getState(), this.notificationPort = l, this.storageService = c, r.subscribe((h, C) => {
+      this.sessionState = h;
+    });
+  }
+  onEndMessageData(t) {
+    this.eventBusService.gatewayOnEndMessageData(t);
+  }
+  offEndMessageData(t) {
+    this.eventBusService.gatewayOffEndMessageData(t);
+  }
+  /**
+   * Send the user's answer to a parked `ask_user` tool call back to the agent.
+   * Default no-op; the WebSocket gateway (AgentGatewayWSAsync) overrides it to emit
+   * a ChatAction.AnswerHumanTool frame.
+   */
+  answerHumanTool(t, e) {
+    console.warn("answerHumanTool: not supported by this gateway", t, e);
+  }
+  getAgentContext() {
+    return this.config;
+  }
+  getModel() {
+    return this.config.model;
+  }
+  setModel(t) {
+    this.config = { ...this.config, model: t };
+  }
+  /**
+   * Live update for the agent / customer slice of the gateway's
+   * config. Mirrors {@link setModel}'s in-place pattern so the
+   * next outgoing message — `sendMessageInternal` reads
+   * `this.config.agentConfig?.id` directly at send time, see
+   * `AgentGatewayWSAsync.sendMessageInternal` — picks up the new
+   * id without rebuilding the gateway or tearing down the
+   * WebSocket. This is what the host calls from the agent picker
+   * so switching agents preserves the current session's
+   * connection, chat history, and any in-flight stream state
+   * instead of remounting `AiChatProvider` and losing them.
+   *
+   * Callers should pass the FULL replacement context (the same
+   * shape they originally constructed the gateway with). The
+   * gateway preserves the `model` slice from its current config
+   * if the incoming context omits it — the model is owned
+   * separately by `setModel` and shouldn't get clobbered by an
+   * agent-only change.
+   */
+  setAgentContext(t) {
+    this.config = {
+      ...t,
+      model: t.model ?? this.config.model
+    };
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getErrorEvent(t) {
+    return {
+      interaction_id: this.getCurrentInteractionId(),
+      model_session_id: "",
+      mime_type: "text/plain",
+      partial: !1,
+      serverError: t
+    };
+  }
+  setSession(t, e) {
+    (this.sessionId === void 0 || this.sessionId != t) && (this.sessionId = t, this.msg_order = this.sessionState.messages.length), e && (this.toolSessionId = e);
+  }
+  startInteraction(t, e, s) {
+    if (e && this.currentIS)
+      return this.currentIS.interaction.isSuspended = !1, this.currentIS.interaction.interactionQuestion += " + " + t, this.currentIS.interaction;
+    this.msg_order += 1;
+    let n = this.getNewInteractionId();
+    s && (n = s);
+    let i = {
+      created: /* @__PURE__ */ new Date(),
+      interactionId: n,
+      artifactData: [],
+      partial: !0,
+      sessionId: this.sessionId,
+      turn_complete: !1,
+      parts: [],
+      version: 0,
+      functionMap: /* @__PURE__ */ new Map(),
+      interactionQuestion: t
+    };
+    return this.interactionsMap.set(i.interactionId, i), this.currentIS = new b(i, this.eventBusService), this.interactionsServiceMap.set(i.interactionId, this.currentIS), i;
+  }
+  getInteractions() {
+    return Array.from(this.interactionsMap.values());
+  }
+  getRecentInteractions(t = 1e3 * 60) {
+    return Array.from(this.interactionsMap.values()).filter((e) => e.created.getTime() > Date.now() - t);
+  }
+  updateMap(t) {
+    let e = this.interactionsServiceMap.get(t.interactionId);
+    if (!e) {
+      var s = this.startInteraction("Unknown", !1, t.interactionId);
+      e = this.interactionsServiceMap.get(s.interactionId);
+    }
+    return e.merge(t);
+  }
+  getCurrentInteractionId() {
+    return this.currentIS ? this.currentIS.interaction.interactionId : null;
+  }
+  getCurrentInteraction() {
+    var t;
+    return ((t = this.currentIS) == null ? void 0 : t.interaction) ?? null;
+  }
+  getInteraction(t) {
+    return this.interactionsMap.get(t);
+  }
+  hasState() {
+    return this.interactionsMap.size > 0;
+  }
+  buildAgentParams() {
+    let t = `agent=${encodeURIComponent(this.config.agentConfig.name ?? "unset")}`;
+    return this.config.customer && (t += `&customer_id=${encodeURIComponent(this.config.customer.dataSetId)}`, t += `&customer_name=${encodeURIComponent(this.config.customer.name)}`), t;
+  }
+  openConnection(t) {
+    throw "Not implemented";
+  }
+  async Error(t = void 0) {
+    console.error("Stream error: ", t), await this.eventBusService.gatewayEmitStreamError(t ?? "");
+  }
+  hasServerSessionId() {
+    return this.server_session_id != null && this.server_session_id != null;
+  }
+  async asyncLoadArtifact(t) {
+    let e = null;
+    const s = this.runningRequests.get(t);
+    s ? (console.warn("GOT A running promise", t), e = s) : (e = this.artifactService.getArtifact(t), this.runningRequests.set(t, e));
+    try {
+      return await e;
+    } catch (n) {
+      return console.error("Error awating on HTML promise", n.toString()), null;
+    } finally {
+      this.runningRequests.delete(t);
+    }
+  }
+  processComands(t) {
+    switch (t.command) {
+      case "open_turn":
+        console.warn("[Stack:] author:", t.author), this.localOpen(t.interactionId, t.author);
+        break;
+      case "ignore":
+        return !0;
+    }
+    return !1;
+  }
+  getOrCreateSubAgentInteraction(t, e, s) {
+    let n = this.subAgentInteractions.get(t), i = this.subAgentInteractionServices.get(t);
+    return (!n || !i) && (n = {
+      created: /* @__PURE__ */ new Date(),
+      interactionId: e,
+      artifactData: [],
+      partial: !0,
+      turn_complete: !1,
+      parts: [],
+      version: 0,
+      functionMap: /* @__PURE__ */ new Map(),
+      interactionQuestion: s ?? t
+    }, i = new b(n, this.eventBusService), this.subAgentInteractions.set(t, n), this.subAgentInteractionServices.set(t, i)), { interaction: n, service: i };
+  }
+  handleSubAgentEvent(t) {
+    const e = t.subAgentId, { service: s } = this.getOrCreateSubAgentInteraction(e, t.interactionId, t.subAgentName);
+    if (t.parts && t.parts.length > 0) {
+      for (const r of t.parts)
+        if (r.toolDetails) {
+          this.localEmitToolEvent({ ...r.toolDetails, subAgentId: e });
+          continue;
+        }
+    }
+    const n = s.merge(t);
+    if (!n) return;
+    const i = t.turn_complete ?? !1;
+    this.sessionState.setSubAgentMessage(e, n.updatedInteraction, t.subAgentName), i && this.sessionState.completeSubAgent(e);
+  }
+  async Message(t) {
+    try {
+      let e;
+      if (typeof t == "object" && Object.keys(t).includes("mimeType"))
+        e = t;
+      else {
+        console.error("Uknown message type", t);
+        return;
+      }
+      if (e.subAgentId) {
+        this.handleSubAgentEvent(e);
+        return;
+      }
+      if (e.serverError && console.error("Stream error: ", e.serverError), e.endMessageData && this.eventBusService.gatewayEmitEndMessageData(e.endMessageData), e) {
+        if (e.llmArtifacts && e.llmArtifacts.length > 0)
+          for (const i of e.llmArtifacts) {
+            const r = i.toArtifact();
+            this.artifactService.addToCache(r), this.eventBusService.artifactEmitGenerated(r);
+          }
+        if (e.parts && e.parts.length > 0) {
+          for (const i of e.parts)
+            if (i.toolDetails) {
+              this.localEmitToolEvent(i.toolDetails);
+              continue;
+            }
+        }
+        const s = this.updateMap(e);
+        if (!s) {
+          console.warn({
+            message: "No updated interaction",
+            type: "warning"
+          }), console.error("No updated interaction");
+          return;
+        }
+        this.localEmitMessage(s.updatedInteraction, s), e.turn_complete && this.turnComplete(e.interactionId, s.updatedInteraction, e.author, e.subAgentId), e.asyncFinalResponse && (e.turn_complete = !0, s.updatedInteraction.turn_complete == !0, this.finalResponse(e.interactionId, s.updatedInteraction, e.author, e.subAgentId));
+        const n = e.artifactsDelta;
+        n && n.forEach((i) => {
+          const r = s.updatedInteraction.artifactData.filter((c) => c.id == i);
+          let l = null;
+          r && r.length > 0 && (l = r[0], l.loadingPromise = this.asyncLoadArtifact(i).then((c) => (c === null ? console.error("Error trying to load artifact id:", l == null ? void 0 : l.id, "Artifact is null") : this.eventBusService.artifactEmitGenerated(c), c)).catch((c) => (console.error("Error trying to load artifact id:", l == null ? void 0 : l.id, c.toString()), null)));
+        });
+      }
+    } catch (e) {
+      if (this.getCurrentInteractionId()) {
+        const s = lt.createErrorEvent("OnMessage error: " + e.toString(), this.getCurrentInteractionId() ?? "Empty Current"), n = this.updateMap(s);
+        if (console.error("Error event: ", JSON.stringify(s, void 0, 4)), !n) {
+          console.error("Error event, could not update interaction: ", JSON.stringify(s, void 0, 4));
+          return;
+        }
+        this.localEmitMessage(n.updatedInteraction);
+      }
+    }
+  }
+  hasOneCompleteInteraction() {
+    var t;
+    return this.interactionsMap.size > 0 && ((t = this.interactionsMap.values().next().value) == null ? void 0 : t.turn_complete) === !0;
+  }
+  localEmitToolEvent(t) {
+    this.sessionState.setLastToolEvent(t), this.eventBusService.gatewayEmitToolEvent(t.eventName, t.eventData, t.sessionId);
+  }
+  registerInteractionCallId(t, e) {
+    e != null && e.callId && this.interactionCallIds.set(t, e.callId);
+  }
+  localEmitFirstToken(t) {
+    this.eventBusService.gatewayEmitFirstToken({
+      interactionId: t,
+      callId: this.interactionCallIds.get(t)
+    });
+  }
+  doEmitMessage(t, e, s) {
+    this.sessionState.setCurrentMessage(t), this.lastCurrentMessageUpdate = e, this.pendingCurrentMessage = null, this.eventBusService.gatewayEmitMessage(t, s);
+  }
+  localEmitMessage(t, e) {
+    const s = (/* @__PURE__ */ new Date()).getTime(), n = s - this.lastCurrentMessageUpdate;
+    t.partial === !1 || n >= D.CURRENT_MSG_THROTTLE_MS ? (this.lastThorttledTimeout && (clearTimeout(this.lastThorttledTimeout), this.lastThorttledTimeout = null), this.doEmitMessage(t, s, e), this.pendingCurrentMessage = null) : (this.pendingCurrentMessage = t, this.lastThorttledTimeout && clearTimeout(this.lastThorttledTimeout), this.lastThorttledTimeout = setTimeout(() => {
+      var r, l;
+      this.pendingCurrentMessage && (((r = this.pendingCurrentMessage) == null ? void 0 : r.version) ?? 0) > (((l = this.sessionState.currentMessage) == null ? void 0 : l.version) ?? 0) && (this.doEmitMessage(this.pendingCurrentMessage, s, e), this.lastThorttledTimeout = null);
+    }, D.CURRENT_MSG_THROTTLE_MS * 2));
+  }
+  localOpen(t, e) {
+    this.sessionState.setTurnOpen(!0), this.eventBusService.gatewayEmitTurnOpen(t ?? "");
+  }
+  /**
+   * Drop any throttled `currentMessage` emit still queued by
+   * `localEmitMessage`. The throttle's trailing edge is a `setTimeout` that
+   * calls `setCurrentMessage(...)`; if it fires *after* the turn has been
+   * committed (`setNewMessage` moved the interaction into `messages` and
+   * nulled `currentMessage`), it re-publishes the now-committed interaction
+   * as the live message — so the chat renders the turn twice: once in
+   * history (`MessageAgent` with `onGoing=false`, which drops Thought parts)
+   * and once as the live `currentMessage` (`onGoing=true`, which keeps them).
+   * That is the duplicated-bubble bug (the two copies even look different —
+   * only the live one shows the "thought" strip). Call this on turn commit.
+   */
+  cancelPendingCurrentMessage() {
+    this.lastThorttledTimeout && (clearTimeout(this.lastThorttledTimeout), this.lastThorttledTimeout = null), this.pendingCurrentMessage = null;
+  }
+  async turnComplete(t, e, s, n) {
+    this.cancelPendingCurrentMessage(), this.sessionState.setNewMessage(e), this.eventBusService.gatewayEmitTurnComplete(t, e), this.interactionCallIds.delete(t), this.sessionState.setLastToolEvent(null), this.localEmitToolEvent({
+      eventName: "todolistUpdated",
+      eventData: "",
+      subAgentId: n
+    }), this.sessionState.setTurnOpen(!1);
+  }
+  async handlePing() {
+    return Date.now() - this.lastPing.getTime() > Nt ? await this.ping() ? (this.lastPing = /* @__PURE__ */ new Date(), this.lastPingStatus = !0, !0) : (this.lastPingStatus = !1, !1) : (this.lastPingStatus = !0, !0);
+  }
+  async sendMessage(t, e) {
+    let s = this.getInteractions().length, n = A.createWaiting(!0, !0, "Overall", /* @__PURE__ */ new Date());
+    this.sendStatusMessage(t.data, [n], s.toString() + "1");
+    try {
+      const { promptAsString: i, json: r } = this.sessionState.onRenderPrompt ? this.sessionState.onRenderPrompt(t.data) : { promptAsString: t.data, json: void 0 };
+      this.sessionState.onRenderPrompt && (t.data = r, t.friendlyMessage = i);
+      const l = await this.sendMessageInternal(t, e), c = At.createPrompt(i ?? "", (r == null ? void 0 : r.toString()) ?? {});
+      this.storageService.storePrompt(c);
+      const u = A.fromText("Planejando próximos passos");
+      return this.sendStatusMessage(t.data, [n, u], s.toString() + "1"), l != null && l.success ? this.eventBusService.ChatEmitMessageSent(t.data, l.interaction) : this.eventBusService.ChatEmitMessageError((l == null ? void 0 : l.error) ?? ""), l;
+    } catch (i) {
+      return this.eventBusService.ChatEmitMessageError((i == null ? void 0 : i.toString()) ?? ""), {
+        success: !1,
+        interaction: {
+          artifactData: [],
+          created: /* @__PURE__ */ new Date(),
+          interactionId: "",
+          partial: !1,
+          parts: [A.fromError((i == null ? void 0 : i.toString()) ?? "")],
+          version: 0
+        }
+      };
+    } finally {
+      this.clearStatus();
+    }
+  }
+  async check() {
+    return !0;
+  }
+  startAndForget() {
+  }
+  forceReceiveMessage(t) {
+    t.partial = !0, t.turn_complete = !1, t.asyncFinalResponse = !1, t.interactionId = t.interactionId, this.eventBusService.gatewayEmitTurnOpen(t.interactionId), this.Message(t);
+  }
+  sendStatusMessage(t, e, s) {
+    var i, r;
+    let n;
+    ((r = (i = this.currentIS) == null ? void 0 : i.interaction) == null ? void 0 : r.turn_complete) === !1 ? (n = Dt.cloneDeep(this.currentIS.interaction), n.parts.push(...e)) : n = {
+      interactionId: "tmp" + s,
+      created: /* @__PURE__ */ new Date(),
+      partial: !0,
+      turn_complete: !1,
+      version: 0,
+      parts: e,
+      interactionQuestion: t,
+      artifactData: []
+    }, this.localEmitMessage(n);
+  }
+  clearStatus() {
+  }
+  async ping() {
+    var t;
+    try {
+      const e = await fetch(this.base_url + "/ping"), s = await e.json();
+      return e.ok == !0 && ((t = s == null ? void 0 : s.debug) == null ? void 0 : t.id) != null;
+    } catch (e) {
+      return console.error("Error pinging server", e), !1;
+    }
+  }
+  getNewInteractionId() {
+    const e = Ot(/* @__PURE__ */ new Date(), "MMM_dd_HH_mm_ss");
+    return `${this.msg_order}_${e}`;
+  }
+};
+g(D, "AgentGatewayService"), a(D, "SUSPENSION_MSG", "SUSPEND"), a(D, "CURRENT_MSG_THROTTLE_MS", 20);
+let B = D;
+const $ = 4001, Pt = 4002, it = 4, kt = 3, _t = 500, Ft = 3e4, Rt = 2, bt = 0.2, at = 2, z = class z {
+  constructor(t = "ws://localhost:8000", e) {
+    a(this, "ws", null);
+    a(this, "stats");
+    a(this, "baseUrl");
+    /**
+     * Optional callback that returns the current JWT. We re-evaluate it on every connect/reconnect
+     * so that a refreshed token is picked up automatically. Browsers can't set the Authorization
+     * header on the WebSocket handshake, so we pass the JWT via the ?access_token= query string,
+     * which the .NET JwtBearer events handler reads in Program.cs.
+     */
+    a(this, "getToken");
+    a(this, "onEvent");
+    a(this, "onError");
+    a(this, "onOpen");
+    a(this, "onFirstToken");
+    a(this, "onSuspended");
+    a(this, "onPong");
+    a(this, "onClose");
+    /** Fired when an unexpected close triggers a reconnect attempt. */
+    a(this, "onReconnecting");
+    /** Fired the first time the socket reopens after an unexpected close. */
+    a(this, "onReconnected");
+    /**
+     * Fired when the server signals that we lost streaming events on resume — our
+     * `lastSeq` fell off the end of the in-memory replay buffer. Consumers should
+     * reset partial-streaming UI for this session and rely on persisted history.
+     */
+    a(this, "onRewindLost");
+    a(this, "sessionId");
+    a(this, "onNewPacket");
+    /**
+     * Stats can fire dozens of times per second during streaming. We
+     * coalesce to a fixed cadence so subscribers see steady,
+     * digestible updates instead of a per-packet firehose — the
+     * latter caused a "Maximum update depth exceeded" cascade in
+     * heavy v2 surfaces (RunProgressPanelV2 + StreamStatistics +
+     * ChatTranscript all subscribed to `statistics` and re-rendered
+     * on every packet, with their useEffect-driven setStates pushing
+     * React's nested-update counter past its threshold).
+     */
+    a(this, "statsFlushTimer", null);
+    a(this, "statsLastFlushed", 0);
+    a(this, "STATS_FLUSH_MS", 120);
+    a(this, "monitorInterval", null);
+    a(this, "streamingResponseSerializer");
+    a(this, "events");
+    a(this, "lastActivity");
+    a(this, "pingPongStack");
+    a(this, "firstTokenInteractions");
+    /** Last sessionId we successfully had — used to resume on reconnect. */
+    a(this, "lastKnownSessionId");
+    /** True when the consumer called `disconnect()` — suppresses auto-reconnect. */
+    a(this, "intentionalDisconnect", !1);
+    /** Number of reconnect attempts since the last clean open. */
+    a(this, "reconnectAttempts", 0);
+    a(this, "reconnectTimer", null);
+    /** True while we are in the middle of an unexpected-close → reconnect cycle. */
+    a(this, "isReconnecting", !1);
+    /** Internal flag set by `scheduleReconnect` so `connect()` does not reset the backoff state. */
+    a(this, "_internalReconnect", !1);
+    /**
+     * Highest server-assigned `seq` we have observed and processed. The next
+     * reconnect appends `?lastSeq={lastSeq}` so the server can replay anything
+     * we missed from the InteractionRun's in-memory buffer. -1 means "haven't
+     * seen any sequenced events yet" (fresh connection).
+     */
+    a(this, "lastSeq", -1);
+    /**
+     * True once *any* socket on this instance has received at least one packet.
+     * Used by `onclose` to distinguish a real mid-stream drop (we had a working
+     * channel) from a connect attempt that never produced traffic (server down,
+     * unreachable, etc.). The inner reconnect loop is only meant for the former
+     * — fresh-connect failures should be handed straight to the outer
+     * SessionStateManagerService.processRetryLoop instead of being retried
+     * twice in here. Sticky for the lifetime of this connection instance so
+     * that internal resume attempts keep their full inner-loop budget even
+     * when a replacement socket fails before delivering its first message.
+     * Cleared by `disconnect()`.
+     */
+    a(this, "hasEverReceivedPacket", !1);
+    this.baseUrl = t, this.getToken = e, this.pingPongStack = [], this.events = [], this.firstTokenInteractions = /* @__PURE__ */ new Set(), this.streamingResponseSerializer = St(), console.log("SOCKET INSTACE", pt()), this.stats = {
+      eventCount: 0,
+      unknonwCount: 0,
+      buffer: [],
+      startTime: /* @__PURE__ */ new Date(),
+      elapsed: 0,
+      unparsedCount: 0,
+      totalTransfered: 0,
+      tokensPerSecond: 0
+    }, this.lastActivity = (/* @__PURE__ */ new Date()).getTime();
+  }
+  /**
+   * Connect to the WebSocket endpoint
+   */
+  connect(t) {
+    return new Promise(async (e, s) => {
+      var m;
+      this.intentionalDisconnect = !1;
+      const n = this._internalReconnect;
+      n || (this.cancelPendingReconnect(), this.isReconnecting = !1, this.reconnectAttempts = 0, this.lastSeq = -1), this._internalReconnect = !1;
+      const i = (m = this.getToken) == null ? void 0 : m.call(this), r = [];
+      i && r.push(`access_token=${encodeURIComponent(i)}`), t && this.lastSeq >= 0 && r.push(`lastSeq=${this.lastSeq}`);
+      const l = r.length > 0 ? `?${r.join("&")}` : "", c = this.baseUrl.replace(/^http:\/\//, "ws://").replace(/^https:\/\//, "wss://"), u = `${c}/ws/connect/${t ?? ""}${l}`, d = `${c}/ws/connect/${t ?? ""}` + (n && t && this.lastSeq >= 0 ? ` (resume lastSeq=${this.lastSeq})` : "");
+      if (console.log("Connecting to ", d), this.ws) {
+        this.ws.onopen = null, this.ws.onmessage = null, this.ws.onerror = null, this.ws.onclose = null;
+        try {
+          this.ws.close();
+        } catch {
+        }
+        this.ws = null;
+      }
+      this.ws = new WebSocket(u), console.log("[WebSocket] Connecting to:", `${c}/ws/connect/${t ?? ""}`);
+      let h = !1;
+      this.ws.onopen = () => {
+        console.log("[WebSocket] Connected");
+        const f = this.isReconnecting;
+        this.isReconnecting = !1, this.reconnectAttempts = 0, this.pingPongStack.push((/* @__PURE__ */ new Date()).getTime()), this.ping(), this.monitor(), this.onOpen && this.onOpen(), f && this.onReconnected && this.onReconnected(t ?? this.lastKnownSessionId ?? "");
+      }, this.ws.onmessage = (f) => {
+        try {
+          this.lastActivity = (/* @__PURE__ */ new Date()).getTime();
+          const w = this.streamingResponseSerializer.parse(f.data);
+          if (!w)
+            throw "Error parsing event JSON";
+          const O = this.handleMessage(w, f.data);
+          !h && (O != null && O.timestamp) && (h = !0, this.hasEverReceivedPacket = !0);
+        } catch (w) {
+          console.error("[WebSocket] Error parsing message:", w);
+        }
+      }, this.ws.onerror = (f) => {
+        console.error("[WebSocket] Error:", f), this.onError && this.onError("WebSocket error");
+      }, this.ws.onclose = (f) => {
+        console.log("[WebSocket] Closed:", f.code, f.reason), this.monitorInterval && (clearInterval(this.monitorInterval), this.monitorInterval = null), this.pingPongStack = [];
+        const w = this.sessionId ?? this.lastKnownSessionId;
+        if (this.sessionId = void 0, (h || this.hasEverReceivedPacket) && this.shouldAttemptReconnect(f.code)) {
+          this.scheduleReconnect(w, f.code, f.reason);
+          return;
+        }
+        this.isReconnecting = !1, this.reconnectAttempts = 0, this.onClose && this.onClose(f.code, f.reason);
+      };
+      let C = 0;
+      for (this.sessionId = void 0; !this.sessionId && C < 30; )
+        console.log("Aguardando session Id"), await this.sleep(400), C++;
+      this.sessionId ? (console.log("SUCCESS -  GOT SESSION ID", this.sessionId), this.lastKnownSessionId = this.sessionId, e(this.sessionId)) : s("After 3 seconds no session id was generated");
+    });
+  }
+  /**
+   * Returns true when the close code is something we believe a fresh connect
+   * (with the same sessionId) can recover from. We deliberately do NOT retry
+   * on:
+   *   - 1000 normal closure
+   *   - 1008 policy violation (auth rejected)
+   *   - 4001 our own intentional disconnect
+   *   - 4000-4099 reserved for app-level fatal codes from the server
+   */
+  shouldAttemptReconnect(t) {
+    return !(this.intentionalDisconnect || t === $ || t === Pt || t === 1e3 || t === 1008);
+  }
+  cancelPendingReconnect() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = null);
+  }
+  computeBackoffDelay() {
+    const t = _t * Math.pow(Rt, this.reconnectAttempts), e = Math.min(t, Ft), s = e * bt * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(e + s));
+  }
+  scheduleReconnect(t, e, s) {
+    var i, r;
+    if (this.intentionalDisconnect) return;
+    if (this.reconnectAttempts >= at) {
+      console.warn(
+        `[WebSocket] Reconnect exhausted after ${this.reconnectAttempts} attempts (last code=${e}, reason="${s}"). Handing off to outer state manager.`
+      ), this.isReconnecting = !1, this.reconnectAttempts = 0, this.cancelPendingReconnect(), (i = this.onClose) == null || i.call(this, e, s);
+      return;
+    }
+    this.isReconnecting = !0, this.reconnectAttempts += 1;
+    const n = this.computeBackoffDelay();
+    console.warn(
+      `[WebSocket] Unexpected close (code=${e}, reason="${s}"). Reconnect attempt #${this.reconnectAttempts}/${at} in ${n}ms (resume sessionId=${t ?? "none"}).`
+    ), (r = this.onReconnecting) == null || r.call(this, this.reconnectAttempts, n), this.cancelPendingReconnect(), this.reconnectTimer = setTimeout(async () => {
+      if (this.reconnectTimer = null, !this.intentionalDisconnect)
+        try {
+          this.ws && (this.ws.onopen = null, this.ws.onmessage = null, this.ws.onerror = null, this.ws.onclose = null, this.ws = null), this._internalReconnect = !0, await this.connect(t);
+        } catch (l) {
+          console.error("[WebSocket] Reconnect attempt failed:", l);
+        }
+    }, n);
+  }
+  async sleep(t) {
+    return new Promise((e) => setTimeout(e, t));
+  }
+  /**
+   * Handle incoming messages from server
+   */
+  handleMessage(t, e) {
+    var l, c, u;
+    switch (typeof t.seq == "number" && t.seq > this.lastSeq && (this.lastSeq = t.seq), t.type) {
+      case "Pong":
+        if (this.sessionId = t.sessionId, this.lastKnownSessionId = t.sessionId ?? this.lastKnownSessionId, !t.sessionId) {
+          console.error("Pong response has no SESSION ID");
+          return;
+        }
+        t.accessToken && this.persistRefreshedAccessToken(t.accessToken), this.pingPongStack.pop() || console.warn("Ping pong order broke, on Pong receive"), this.onPong && this.onPong(t.sessionId);
+        break;
+      case "Suspended":
+        this.onSuspended && this.onSuspended();
+        break;
+      case "Event":
+        break;
+      case "RewindLost":
+        console.warn(
+          `[WebSocket] RewindLost: lost events on resume, resuming from seq=${t.seq}`
+        ), typeof t.seq == "number" && (this.lastSeq = t.seq - 1), this.onRewindLost && t.sessionId && this.onRewindLost(t.sessionId, t.seq ?? -1);
+        break;
+      default:
+        console.warn("[WebSocket] Unknown message type:", t.type);
+    }
+    if (t.partialEvent) {
+      const d = t.partialEvent;
+      this.emitFirstToken(d == null ? void 0 : d.iteractionId);
+      const h = new wt();
+      if (h.author = "main", h.streamingParts = t.partialEvent.streamingParts, t.partialEvent.partialEventType ? h.eventType = t.partialEvent.partialEventType : h.eventType = d.functionName ? {
+        fullName: F.StreamingFunctionCallUpdateContent,
+        type: T.PartialFunctionCall
+      } : d.partialReasoning ? {
+        fullName: F.StreamingReasoningContent,
+        type: T.Thought
+      } : {
+        fullName: F.StreamingTextContent,
+        type: T.Text
+      }, h.interactionId = (d == null ? void 0 : d.iteractionId) ?? "", h.mimeType = "text/plain", h.partial = !0, h.eventType.type == T.PartialFunctionCall) {
+        var s = new Tt();
+        s.choiceIndex = 0, s.callId = d.functionCallId, s.arguments = d.partialText, s.name = d.functionName, h.content = {
+          items: [s],
+          role: {
+            label: "Assistant"
+          }
+        };
+      } else if (h.eventType.type == T.Text)
+        if (h.eventType.fullName == F.StreamingTextContent) {
+          var n = new yt();
+          n.text = d.partialText, h.content = {
+            items: [n],
+            role: {
+              label: "Assistant"
+            }
+          };
+        } else {
+          var i = new It();
+          i.text = d.partialText, h.content = {
+            items: [i],
+            role: {
+              label: "Assistant"
+            }
+          };
+        }
+      else if (h.eventType.type == T.Thought) {
+        var r = new Ct();
+        r.text = d.partialReasoning, h.content = {
+          items: [r],
+          role: {
+            label: "Assistant"
+          }
+        };
+      } else
+        t.event = void 0;
+      h.role = {
+        label: "Assistant"
+      }, h.timestamp = (d == null ? void 0 : d.timeStamp) ?? (/* @__PURE__ */ new Date()).getTime(), h.turnComplete = !1, t.event = h, t.partialEvent = void 0;
+    }
+    return t.event ? (t.subAgentId && (t.event.subAgentId = t.subAgentId, t.event.subAgentName = t.subAgentName), ((((c = (l = t.event.content) == null ? void 0 : l.items) == null ? void 0 : c.length) ?? 0) > 0 || (((u = t.event.streamingParts) == null ? void 0 : u.length) ?? 0) > 0) && this.emitFirstToken(t.event.interactionId), this.handleEvent(t.event, e), t.event) : null;
+  }
+  emitFirstToken(t) {
+    var e;
+    !t || this.firstTokenInteractions.has(t) || (this.stats = {
+      eventCount: 0,
+      unknonwCount: 0,
+      buffer: [],
+      startTime: /* @__PURE__ */ new Date(),
+      elapsed: 0,
+      unparsedCount: 0,
+      totalTransfered: 0,
+      tokensPerSecond: 0
+    }, this.firstTokenInteractions.add(t), (e = this.onFirstToken) == null || e.call(this, t));
+  }
+  /**
+   * Mirror a server-side-refreshed JWT into the stored user record so the global
+   * fetch interceptor (packages/dashboard-app/.../EnvisionAuthProvider.tsx) picks
+   * it up on the next HTTP call. Idempotent — the same token is delivered on
+   * multiple consecutive Pong frames for listener-readiness, and we only write
+   * when it actually changed.
+   *
+   * Uses the same localStorage key the auth provider reads (`envision_user`).
+   * Done here in the WS layer rather than via a callback so consumers don't need
+   * to wire up token-handling boilerplate; React contexts that hold the user in
+   * memory will pick up the new token on the next refresh/render or via their
+   * own storage listeners.
+   */
+  persistRefreshedAccessToken(t) {
+    const e = "envision_user";
+    try {
+      const s = localStorage.getItem(e);
+      if (!s) {
+        console.warn("[WebSocket] WS-refreshed token received but no stored user — dropping");
+        return;
+      }
+      const n = JSON.parse(s);
+      if ((n == null ? void 0 : n.access_token) === t) return;
+      n.access_token = t, localStorage.setItem(e, JSON.stringify(n)), console.info("[WebSocket] Mirrored WS-refreshed JWT into stored user");
+    } catch (s) {
+      console.error("[WebSocket] Failed to persist WS-refreshed token", s);
+    }
+  }
+  closeStream() {
+    this.disconnect();
+  }
+  suspendStream() {
+    this.sendBaseMessage({
+      Action: L.Suspend,
+      AgentId: "",
+      InteractionId: "",
+      ModelId: ""
+    });
+  }
+  /** Send the user's answer to a parked ask_user tool call (ChatAction.AnswerHumanTool). */
+  answerHumanTool(t, e) {
+    this.sendBaseMessage({
+      Action: L.AnswerHumanTool,
+      AgentId: "",
+      InteractionId: "",
+      ToolCallId: t,
+      Answer: e
+    });
+  }
+  /**
+   * Send a message to the agent
+   */
+  sendMessage(t) {
+    this.sendBaseMessage(t);
+  }
+  sendBaseMessage(t) {
+    if (this.lastActivity = (/* @__PURE__ */ new Date()).getTime(), !this.ws || this.ws.readyState !== WebSocket.OPEN)
+      throw new Error("WebSocket is not connected");
+    this.ws.send(JSON.stringify(t));
+  }
+  sendSuspendMessage(t) {
+    this.sendMessage(t);
+  }
+  monitor() {
+    const t = this, e = this.pingPongStack, s = 3e4;
+    this.monitorInterval = setInterval(() => {
+      try {
+        const n = (/* @__PURE__ */ new Date()).getTime() - this.lastActivity;
+        t.isConnected() && n >= s - 200 && (e.length > 0 && console.warn("Ping pong stack broke here, on pinging"), e.push((/* @__PURE__ */ new Date()).getTime()), t.ping());
+      } catch (n) {
+        console.error("Error on monitor", n);
+      }
+    }, s);
+  }
+  /**
+   * Send a heartbeat ping
+   */
+  ping() {
+    this.sendBaseMessage({
+      Action: "Ping",
+      AgentId: "",
+      InteractionId: "",
+      ModelId: ""
+    });
+  }
+  /**
+   * Disconnect the WebSocket
+   */
+  disconnect() {
+    console.warn("Chamou DISCONNECT!!!"), this.intentionalDisconnect = !0, this.cancelPendingReconnect(), this.isReconnecting = !1, this.reconnectAttempts = 0, this.monitorInterval && (clearInterval(this.monitorInterval), this.monitorInterval = null), this.pingPongStack = [], this.firstTokenInteractions.clear(), this.lastKnownSessionId = void 0, this.lastSeq = -1, this.hasEverReceivedPacket = !1, this.ws && (this.ws.close($, "Intentional disconnect"), this.ws = null);
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Push the latest stats out to `onNewPacket`, but at most every
+   * `STATS_FLUSH_MS` ms. Subsequent packets within the window
+   * schedule a trailing flush so the UI eventually sees the final
+   * value without each individual packet causing a re-render.
+   */
+  flushStatsCoalesced() {
+    if (!this.onNewPacket) return;
+    const t = Date.now(), e = t - this.statsLastFlushed;
+    if (e >= this.STATS_FLUSH_MS) {
+      this.statsFlushTimer && (clearTimeout(this.statsFlushTimer), this.statsFlushTimer = null), this.statsLastFlushed = t, this.onNewPacket({ ...this.stats });
+      return;
+    }
+    this.statsFlushTimer || (this.statsFlushTimer = setTimeout(() => {
+      var s;
+      this.statsFlushTimer = null, this.statsLastFlushed = Date.now(), (s = this.onNewPacket) == null || s.call(this, { ...this.stats });
+    }, this.STATS_FLUSH_MS - e));
+  }
+  async handleEvent(t, e) {
+    var s;
+    try {
+      const n = lt.parseFromTypedEvent(t);
+      if (!n)
+        throw "Server event was null";
+      this.events.push([(/* @__PURE__ */ new Date()).getTime(), ((s = t.text) == null ? void 0 : s.length) ?? 0]), this.stats.eventCount += 1, this.stats.totalTransfered += e.length, n.session_information && !n.subAgentId && (this.stats.sessionInformation = n.session_information), this.stats.elapsed = (Date.now() - this.stats.startTime.getTime()) / 1e3;
+      const i = Date.now() - it * 1e3, l = this.events.filter((c) => c[0] > i).reduce((c, u) => c += u[1], 0) / kt;
+      this.stats.tokensPerSecond = l / it, this.flushStatsCoalesced(), this.onEvent && this.onEvent(n).catch((c) => {
+        console.error("Lost error on on-event", c);
+      });
+    } catch (n) {
+      console.error("handleEvent error", n);
+    }
+  }
+};
+g(z, "WebSocketConnecionV2");
+let rt = z;
+const Lt = "envision_agent_sessionId", j = class j extends B {
+  constructor(e, s, n, i, r, l, c, u, d, h, C) {
+    super(e, s, n, i, r, l, c, d, C);
+    a(this, "suspendState", !1);
+    a(this, "wsService");
+    a(this, "root_url", "");
+    a(this, "hearBeatPort");
+    a(this, "connectionAttempts", 0);
+    a(this, "statuses", ["CONNECTING", "OPEN", "CLOSED", "UNKNOWN"]);
+    a(this, "lastConnectionPromise", null);
+    a(this, "socketState", P.Disconnected);
+    a(this, "streamOpened", !1);
+    this.hearBeatPort = h, this.root_url = this.base_url, this.wsService = u, this.wsService.onEvent = async (m) => {
+      await super.Message(m);
+    }, this.wsService.onNewPacket = (m) => {
+      this.sessionState.setStatistics(m), this.eventBusService.streamEmitNewChunk(m);
+    }, this.wsService.onPong = (m) => {
+    }, this.wsService.onError = (m) => {
+      this.streamOpened = !1;
+      const f = {
+        data: this.getErrorEvent(m),
+        lastEventId: (/* @__PURE__ */ new Date()).getTime().toString(),
+        origin: "gatewayService"
+      };
+      console.error("Stream error:", m), this.notificationPort.pushNotification({
+        message: "Stream error" + m,
+        type: "warning"
+      }), super.Message(f);
+    }, this.wsService.onOpen = () => {
+      this.sessionState.setConnectionStatus(P.Connected);
+    }, this.wsService.onReconnected = (m) => {
+      this.sessionState.setConnectionStatus(P.Connected);
+    }, this.wsService.onFirstToken = (m) => {
+      this.localEmitFirstToken(m);
+    }, this.wsService.onClose = (m, f) => {
+      m != $ && this.sessionState.setConnectionStatus(P.Disconnected);
+    };
+  }
+  reset(e, s) {
+    throw new Error("Method not implemented.");
+  }
+  startStream(e) {
+    throw new Error("Method not implemented.");
+  }
+  isSuspended() {
+    return this.suspendState;
+  }
+  getStoredSessionId() {
+    const e = localStorage.getItem(Lt);
+    if (e)
+      return e;
+  }
+  isInteractionComplete(e) {
+    const s = this.interactionsMap.get(e);
+    return s == null ? void 0 : s.turn_complete;
+  }
+  isTurnCompleted(e) {
+    const s = this.interactionsMap.get(e);
+    return s == null ? void 0 : s.turn_complete;
+  }
+  async finalResponse(e, s, n) {
+    super.turnComplete(e, s, n);
+  }
+  stopStream(e = !0) {
+    e && this.sessionState.setTurnOpen(!1), this.wsService && this.wsService.closeStream();
+  }
+  async suspend() {
+    const e = this.wsService;
+    return new Promise(async (n, i) => {
+      let r = !1;
+      e.onSuspended = () => {
+        r = !0;
+      }, e.suspendStream();
+      try {
+        let u = 0;
+        for (; !r && u < 5e3; )
+          await this.sleep(100), u += 100;
+        if (r)
+          if (this.currentIS) {
+            const d = this.currentIS.interaction;
+            d.isSuspended = !0, this.sessionState.setCurrentMessage(d), this.sessionState.setTurnOpen(!1), n(!0);
+          } else
+            console.error("CurrentIS is null"), i("CurrentIS is null");
+        else
+          i("Timeout awaiting for suspension");
+      } finally {
+        this.suspendState = !0;
+      }
+    });
+  }
+  answerHumanTool(e, s) {
+    this.wsService.answerHumanTool(e, s);
+  }
+  async cancelSuspend() {
+    var s;
+    const e = (s = this.currentIS) == null ? void 0 : s.interaction;
+    e && (e.isSuspended = !1, this.turnComplete(e.interactionId, e, "Main"));
+  }
+  async check() {
+    return !0;
+  }
+  async openConnection(e) {
+    return this.lastConnectionPromise ? this.lastConnectionPromise : this.socketState == P.Disconnected ? (this.lastConnectionPromise = new Promise((s, n) => {
+      this.wsService.connect(e).then((i) => {
+        this.sessionId = i, s(i);
+      }).catch((i) => {
+        n(i);
+      }).finally(() => {
+        this.lastConnectionPromise = null;
+      });
+    }), this.lastConnectionPromise) : Promise.resolve(this.sessionId);
+  }
+  async closeConnection(e = !0) {
+    try {
+      return this.stopStream(e), {
+        success: !0,
+        interaction: this.getCurrentInteraction()
+      };
+    } catch {
+      return {
+        success: !1,
+        interaction: this.getCurrentInteraction()
+      };
+    }
+  }
+  simulateDisconnect(e = 4500, s = "Debug simulated disconnect") {
+    const n = this.wsService;
+    n != null && n.ws && n.ws.close(e, s);
+  }
+  async sleep(e) {
+    return new Promise((s) => setTimeout(s, e));
+  }
+  // Send a message to the server via HTTP POST
+  async sendMessageInternal(e, s, n) {
+    var l, c, u, d, h, C, m, f;
+    const i = this.suspendState;
+    this.suspendState = !1;
+    const r = this.startInteraction(e.friendlyMessage ?? e.data, i);
+    if (this.registerInteractionCallId(r.interactionId, s), (l = e.userUi) != null && l.name && r.parts.push(A.fromUserUi(e.userUi.name, e.userUi.args)), !this.wsService)
+      throw "no wsService created";
+    if (!this.sessionId)
+      throw "no session id set";
+    if (!((c = this.config.agentConfig) != null && c.id))
+      throw "Agent not selected";
+    return this.wsService.sendMessage({
+      Content: e.data,
+      SessionId: this.sessionId,
+      Action: L.SendMessage,
+      ModelId: this.config.model,
+      InteractionId: r.interactionId,
+      AgentId: (u = this.config.agentConfig) == null ? void 0 : u.id,
+      // Optional explicit C# class name on the server (e.g. "LlmAgentSessionReplay").
+      // When set, AgentBootStrapService.GetAgent dispatches to that class directly
+      // instead of looking up an Agent metadata row by AgentId. Plumbed through
+      // `agentContext.agentConfig.agentImplementation` so a host can run a turn
+      // against any registered LlmAgent variant without seeding a Mongo record.
+      AgentImplementation: (d = this.config.agentConfig) == null ? void 0 : d.agentImplementation,
+      Parameters: {
+        CustomerName: ((h = this.config.customer) == null ? void 0 : h.name) ?? "",
+        DataSet: ((C = this.config.customer) == null ? void 0 : C.dataSetId) ?? ""
+      },
+      // Forward image attachments as a structured payload (PascalCase
+      // keys to match the C# `Message.Images` / `MessageImage` model).
+      Images: (m = e.images) != null && m.length ? e.images.map((w) => ({ MimeType: w.mimeType, Data: w.data })) : void 0,
+      // Client-only UI representation for this turn (PascalCase to match the C# `Message.UserUi`
+      // model). The server persists it as a UserUiContent sibling and strips it from the model
+      // request; Content remains the only model-facing text.
+      UserUi: (f = e.userUi) != null && f.name ? { Name: e.userUi.name, Args: e.userUi.args } : void 0
+    }), this.localOpen(r.interactionId, "system"), Promise.resolve({
+      interaction: r,
+      success: !0
+    });
+  }
+};
+g(j, "AgentGatewayWSAsync");
+let ot = j;
+const Y = class Y {
+  constructor(t, e) {
+    a(this, "cache", /* @__PURE__ */ new Map());
+    a(this, "serverBaseUrl");
+    a(this, "accessToken");
+    this.serverBaseUrl = t.replace(/\/$/, ""), this.accessToken = e;
+  }
+  get headers() {
+    return { Authorization: `Bearer ${this.accessToken}` };
+  }
+  async init() {
+  }
+  getArtifacts() {
+    return Array.from(this.cache.values());
+  }
+  async saveArtifact(t) {
+    this.cache.set(t.id, t);
+  }
+  saveArtifactToCache(t) {
+    this.cache.set(t.id, t);
+  }
+  async deleteArtifact(t) {
+    this.cache.delete(t);
+  }
+  addToCache(t) {
+    this.cache.set(t.id, t);
+  }
+  getArtifactWithCache(t) {
+    return this.cache.get(t) ?? null;
+  }
+  async getArtifact(t, e) {
+    if (this.cache.has(t)) return this.cache.get(t) ?? null;
+    try {
+      const s = await fetch(`${this.serverBaseUrl}/AdminArtifact/${t}`, {
+        headers: this.headers
+      });
+      if (!s.ok) return null;
+      const n = await s.json();
+      return this.cache.set(n.id, n), n;
+    } catch {
+      return null;
+    }
+  }
+  async clearAllArtifacts() {
+    this.cache.clear();
+  }
+  async getFileContent(t) {
+    try {
+      const e = await fetch(t, { headers: this.headers });
+      return e.ok ? await e.text() : null;
+    } catch {
+      return null;
+    }
+  }
+};
+g(Y, "HttpArtifactService");
+let ct = Y;
+export {
+  B as A,
+  x as E,
+  ct as H,
+  b as I,
+  st as L,
+  nt as M,
+  rt as W,
+  ot as a,
+  Kt as u
+};
+//# sourceMappingURL=httpArtifactService-BAR60Gu1.js.map