@aintela/chat 0.2.26 → 0.2.28

package/dist/serializer-BPina6fX.js

@@ -0,0 +1,1337 @@
+var wt = Object.defineProperty;
+var Jt = (s, t, i) => t in s ? wt(s, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : s[t] = i;
+var l = (s, t) => wt(s, "name", { value: t, configurable: !0 });
+var e = (s, t, i) => Jt(s, typeof t != "symbol" ? t + "" : t, i);
+import { E as m, q as Et, A as Wt, G as $t } from "./environmentUtils-CUVZ6Dq1.js";
+import { jsonMember as o, jsonObject as d, AnyT as Ft, jsonArrayMember as ft, TypedJSON as Pt } from "typedjson";
+const w = class w {
+  static replaceFirstTwoTabsPerLine(t) {
+    const i = /^\s{15}/gm;
+    return typeof t == "string" ? t.replaceAll(i, (r) => r.substring(15)) : t ?? "";
+  }
+  static jsonToString(t) {
+    if (t == null) return "";
+    if (typeof t != "object") return String(t);
+    const i = Array.isArray(t) ? w.isCharArray(t) ? t.join("") : null : w.tryCollapseCharIndexedObject(t);
+    if (i != null) return i;
+    if (Array.isArray(t))
+      try {
+        return JSON.stringify(t, null, 2);
+      } catch {
+        return String(t);
+      }
+    const r = Object.keys(t), a = [];
+    return r.forEach((p) => {
+      let c = t[p];
+      typeof c == "object" && (c = JSON.stringify(t[p], null, 2));
+      const g = (c == null ? void 0 : c.toString().indexOf(`
+`)) > -1 ? `
+` : "";
+      a.push(`${p}:${g}${c}`);
+    }), a.join(`
+`);
+  }
+  static functionDetailsToString(t) {
+    if (t == null) return "";
+    if (typeof t == "string") {
+      t = t.replaceAll('"{', "{").replaceAll('}"', "}").replaceAll("'{", "{").replaceAll("}'", "}"), t = t.replaceAll('\\"', '"');
+      try {
+        t = JSON.parse(t);
+      } catch {
+        return t;
+      }
+      if (typeof t != "object" || t == null) return String(t);
+    }
+    if (Array.isArray(t))
+      try {
+        return JSON.stringify(t, null, 2);
+      } catch {
+        return String(t);
+      }
+    const i = Object.keys(t), r = [];
+    return i.forEach((a) => {
+      let p = t == null ? void 0 : t[a];
+      typeof p == "object" && (p = JSON.stringify(p, null, 2));
+      const c = (p == null ? void 0 : p.toString().indexOf(`
+`)) > -1 ? `
+` : "";
+      r.push(`${a}:${c}${p}`);
+    }), r.join(`
+`);
+  }
+  /**
+   * Reads the server-generated SlotId from a UI render tool's result. The
+   * result reaches the client as a plain object on the live path, but as a
+   * JSON string — sometimes double-encoded (a JSON string of a JSON string) —
+   * on the persisted / session-replay path. Unwrap up to two string layers
+   * before reading the field. Returns undefined when absent or unparseable.
+   */
+  static uiSlotId(t) {
+    var p;
+    let i = (p = t == null ? void 0 : t.functionDetails) == null ? void 0 : p.response;
+    for (let c = 0; c < 2 && typeof i == "string"; c++)
+      try {
+        i = JSON.parse(i);
+      } catch {
+        return;
+      }
+    if (!i || typeof i != "object") return;
+    const r = i, a = r.SlotId ?? r.slotId;
+    return typeof a == "string" ? a : void 0;
+  }
+  static fromError(t) {
+    return {
+      errorDetails: { errorMessage: t },
+      eventType: m.ServerError,
+      id: "",
+      author: "main",
+      created: /* @__PURE__ */ new Date(),
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1
+    };
+  }
+  static fromText(t, i, r) {
+    return {
+      text: t,
+      eventType: m.Text,
+      id: r ?? Et(),
+      created: /* @__PURE__ */ new Date(),
+      author: i ?? "main",
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1
+    };
+  }
+  /**
+   * Builds the user-authored UI part for a `sendMessage(text, { ui })` turn. Mirrors the
+   * shape `ServerEvent` produces from a persisted `UserUiContent` on reload, so the live
+   * and replayed parts are identical: an `EventType.UserAnswer` carrying functionDetails
+   * {name, args, isUi, status:'Done'} that routes through the uiTool dispatcher/registry.
+   */
+  static fromUserUi(t, i, r) {
+    return {
+      id: r ?? Et(),
+      eventType: m.UserAnswer,
+      author: "user",
+      created: /* @__PURE__ */ new Date(),
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1,
+      functionDetails: {
+        id: "",
+        name: t,
+        args: i,
+        status: "Done",
+        isUi: !0
+      }
+    };
+  }
+  static createWaiting(t = !1, i = !0, r, a, p) {
+    r || (r = "Waiting");
+    const c = w.fromText("...", void 0, "waitingpart");
+    return c.eventType = m.Waiting, c.waitingDetails = {
+      startingPoint: a,
+      addTimer: t,
+      isTimerRunning: i,
+      status: r,
+      stopPoint: p
+    }, c;
+  }
+  static createSuspended() {
+    const t = w.fromText("SUSPEND");
+    return t.eventType = m.Suspended, t;
+  }
+  static getPartTextContent(t) {
+    return t.text ?? "";
+  }
+  static FlatParts(t) {
+    if (t.length === 0)
+      return;
+    const i = t.filter((p) => p.eventType == m.Text), r = i.length > 0 ? i[0] : t[0], a = [...new Set(t.map((p) => p.eventType))];
+    a.length == 1 ? r.eventType = a[0] : i.length > 0 && (r.eventType = m.Text), r.mustPush = !(r.eventType == m.Text || r.eventType == m.Thought || r.eventType == m.NotDefined || r.eventType == m.PartialFunctionCall), r.textAppendable = r.eventType == m.Text || r.eventType == m.Thought || r.eventType == m.PartialFunctionCall;
+    for (const p of t) {
+      if (!r.codeExecutionResultDetails && p.codeExecutionResultDetails && (r.codeExecutionResultDetails = p.codeExecutionResultDetails), !r.errorDetails && p.errorDetails && (r.errorDetails = p.errorDetails), !r.executableCodeDetails && p.executableCodeDetails && (r.executableCodeDetails = p.executableCodeDetails), !r.functionDetails && p.functionDetails && (r.functionDetails = p.functionDetails), r.functionDetails && p.functionDetails && p !== r) {
+        const c = r.functionDetails, g = p.functionDetails;
+        !c.askUserComponent && g.askUserComponent && (c.askUserComponent = g.askUserComponent), !c.isUi && g.isUi && (c.isUi = !0), !c.clientOutput && g.clientOutput && (c.clientOutput = g.clientOutput), c.isAskUser = c.isAskUser || g.isAskUser || !!c.askUserComponent;
+      }
+      !r.rawDetails && p.rawDetails && (r.rawDetails = p.rawDetails), !r.thoughtDetails && p.thoughtDetails && (r.thoughtDetails = p.thoughtDetails), !r.errorDetails && p.errorDetails && (r.errorDetails = p.errorDetails);
+    }
+    return r;
+  }
+  static isCharArray(t) {
+    return Array.isArray(t) && t.length > 0 && t.every((i) => typeof i == "string" && i.length === 1);
+  }
+  /**
+   * Detects objects like `{0: "a", 1: "b", 2: "c", ...}` — a string that was
+   * spread/indexed into an object (e.g. `{...someString}` or the server
+   * serializing a string as a char-indexed dict). Returns the reassembled
+   * string, or `null` if the value doesn't match this pattern.
+   */
+  static tryCollapseCharIndexedObject(t) {
+    if (t == null || typeof t != "object" || Array.isArray(t)) return null;
+    const i = Object.keys(t);
+    if (i.length === 0) return null;
+    for (let r = 0; r < i.length; r++) {
+      if (i[r] !== String(r)) return null;
+      const a = t[i[r]];
+      if (typeof a != "string" || a.length !== 1) return null;
+    }
+    return i.map((r) => t[r]).join("");
+  }
+  static isCodeExecution(t) {
+    return t.eventType === m.CodeExecutionResult || t.eventType === m.ExecutableCode;
+  }
+};
+l(w, "InteractionPartUtils");
+let Nt = w;
+var Gt = Object.defineProperty, qt = Object.getOwnPropertyDescriptor, n = /* @__PURE__ */ l((s, t, i, r) => {
+  for (var a = r > 1 ? void 0 : r ? qt(t, i) : t, p = s.length - 1, c; p >= 0; p--)
+    (c = s[p]) && (a = (r ? c(t, i, a) : c(a)) || a);
+  return r && a && Gt(t, i, a), a;
+}, "__decorateClass");
+const x = {
+  // KernelContent derived types
+  TextContent: "TextContent",
+  ToolEventContent: "ToolEventContent",
+  StreamingToolEventContent: "StreamingToolEventContent",
+  StreamingReasoningContent: "StreamingReasoningContent",
+  FunctionCallContent: "FunctionCallContent",
+  FunctionResultContent: "FunctionResultContent",
+  FunctionClientOutputContent: "FunctionClientOutputContent",
+  UserUiContent: "UserUiContent",
+  // StreamingKernelContent derived types
+  StreamingTextContent: "StreamingTextContent",
+  StreamingFunctionCallUpdateContent: "StreamingFunctionCallUpdateContent",
+  StreamingFinalFunctionCallContent: "StreamingFinalFunctionCallContent",
+  StreamingFinalFunctionResultContent: "StreamingFinalFunctionResultContent",
+  StreamingClientOutputContent: "StreamingClientOutputContent"
+};
+var _;
+let Tt = (_ = class {
+  constructor() {
+    e(this, "label");
+  }
+}, l(_, "AuthorRole"), _);
+n([
+  o(String)
+], Tt.prototype, "label", 2);
+Tt = n([
+  d({ name: "AuthorRole" })
+], Tt);
+var L;
+let ut = (L = class {
+  constructor() {
+    e(this, "type");
+    e(this, "fullName");
+  }
+}, l(L, "EventTypeInformation"), L);
+n([
+  o(String)
+], ut.prototype, "type", 2);
+n([
+  o(String)
+], ut.prototype, "fullName", 2);
+ut = n([
+  d({ name: "EventTypeInformation" })
+], ut);
+var J;
+let R = (J = class {
+  constructor() {
+    e(this, "id");
+    e(this, "name");
+    e(this, "mimeType");
+    e(this, "description");
+  }
+  toArtifact() {
+    return {
+      created: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      name: this.name ?? "Not Defined",
+      description: this.description,
+      mimeType: this.mimeType,
+      id: this.id
+    };
+  }
+}, l(J, "LlmArtifact"), J);
+n([
+  o(String)
+], R.prototype, "id", 2);
+n([
+  o(String)
+], R.prototype, "name", 2);
+n([
+  o(String)
+], R.prototype, "mimeType", 2);
+n([
+  o(String)
+], R.prototype, "description", 2);
+R = n([
+  d({ name: "LlmArtifact" })
+], R);
+var W;
+let h = (W = class {
+  constructor() {
+    e(this, "mimeType");
+    // InnerContent is ignored (JsonIgnore in C#)
+    // Not decorated with @jsonMember
+    e(this, "innerContent");
+    e(this, "modelId");
+    e(this, "metadata");
+  }
+}, l(W, "KernelContent"), W);
+n([
+  o(String)
+], h.prototype, "mimeType", 2);
+n([
+  o(String)
+], h.prototype, "modelId", 2);
+n([
+  o(Ft)
+], h.prototype, "metadata", 2);
+h = n([
+  d({ name: "KernelContent" })
+], h);
+var $;
+let C = ($ = class {
+  constructor() {
+    e(this, "choiceIndex", 0);
+    // InnerContent is ignored (JsonIgnore in C#)
+    // Not decorated with @jsonMember
+    e(this, "innerContent");
+    e(this, "modelId");
+    e(this, "metadata");
+  }
+}, l($, "StreamingKernelContent"), $);
+n([
+  o(Number)
+], C.prototype, "choiceIndex", 2);
+n([
+  o(String)
+], C.prototype, "modelId", 2);
+n([
+  o(Object)
+], C.prototype, "metadata", 2);
+C = n([
+  d({ name: "StreamingKernelContent" })
+], C);
+var G;
+let xt = (G = class extends h {
+  constructor() {
+    super();
+    e(this, "text");
+    // Encoding is ignored (JsonIgnore in C#)
+    // Not decorated with @jsonMember
+    e(this, "encoding");
+    this.encoding = "UTF8";
+  }
+  toString() {
+    return this.text ?? "";
+  }
+}, l(G, "TextContent"), G);
+n([
+  o(String)
+], xt.prototype, "text", 2);
+xt = n([
+  d({ name: "TextContent" })
+], xt);
+var q;
+let ct = (q = class extends C {
+  constructor() {
+    super();
+    e(this, "eventName");
+    e(this, "eventData");
+    e(this, "sessionId");
+  }
+}, l(q, "StreamingToolEventContent"), q);
+n([
+  o(String)
+], ct.prototype, "eventName", 2);
+n([
+  o(String)
+], ct.prototype, "eventData", 2);
+n([
+  o(String)
+], ct.prototype, "sessionId", 2);
+ct = n([
+  d({ name: "StreamingToolEventContent" })
+], ct);
+var M;
+let P = (M = class extends h {
+  constructor() {
+    super();
+    e(this, "eventName");
+    e(this, "eventData");
+    e(this, "sessionId");
+  }
+}, l(M, "ToolEventContent"), M);
+n([
+  o(String)
+], P.prototype, "eventName", 2);
+n([
+  o(String)
+], P.prototype, "eventData", 2);
+n([
+  o(String)
+], P.prototype, "sessionId", 2);
+P = n([
+  d({ name: "ToolEventContent" })
+], P);
+var B;
+let ht = (B = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "url");
+    e(this, "dataUri");
+  }
+}, l(B, "ImageContent"), B);
+n([
+  o(String)
+], ht.prototype, "url", 2);
+n([
+  o(String)
+], ht.prototype, "dataUri", 2);
+ht = n([
+  d({ name: "ImageContent" })
+], ht);
+var K;
+let A = (K = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "pluginName");
+    e(this, "functionName");
+    e(this, "arguments");
+    // Exception is not serializable - omit jsonMember decorator
+    e(this, "exception");
+  }
+}, l(K, "FunctionCallContent"), K);
+n([
+  o(String)
+], A.prototype, "id", 2);
+n([
+  o(String)
+], A.prototype, "pluginName", 2);
+n([
+  o(String)
+], A.prototype, "functionName", 2);
+n([
+  o(Ft)
+], A.prototype, "arguments", 2);
+A = n([
+  d({ name: "FunctionCallContent" })
+], A);
+var H;
+let v = (H = class {
+  constructor() {
+    e(this, "isUi");
+    e(this, "askUserComponent");
+    e(this, "argsDescription");
+  }
+}, l(H, "ToolCallPresentation"), H);
+n([
+  o(Boolean)
+], v.prototype, "isUi", 2);
+n([
+  o(String)
+], v.prototype, "askUserComponent", 2);
+n([
+  o(String)
+], v.prototype, "argsDescription", 2);
+v = n([
+  d({ name: "ToolCallPresentation" })
+], v);
+const Mt = "aia:presentation";
+var Y;
+let b = (Y = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "functionName");
+    e(this, "arguments");
+    e(this, "presentation");
+  }
+}, l(Y, "StreamingFinalFunctionCallContent"), Y);
+n([
+  o(String, { name: "callId" })
+], b.prototype, "id", 2);
+n([
+  o(String, { name: "name" })
+], b.prototype, "functionName", 2);
+n([
+  o(String)
+], b.prototype, "arguments", 2);
+n([
+  o(v)
+], b.prototype, "presentation", 2);
+b = n([
+  d({ name: "StreamingFinalFunctionCallContent" })
+], b);
+var Q;
+let U = (Q = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "pluginName");
+    e(this, "functionName");
+    e(this, "result");
+  }
+}, l(Q, "FunctionResultContent"), Q);
+n([
+  o(String, { name: "callId" })
+], U.prototype, "id", 2);
+n([
+  o(String)
+], U.prototype, "pluginName", 2);
+n([
+  o(String)
+], U.prototype, "functionName", 2);
+n([
+  o(Ft)
+], U.prototype, "result", 2);
+U = n([
+  d({ name: "FunctionResultContent" })
+], U);
+var V;
+let I = (V = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "pluginName");
+    e(this, "functionName");
+    e(this, "result");
+    e(this, "presentation");
+    e(this, "clientOutput");
+  }
+}, l(V, "StreamingFinalFunctionResultContent"), V);
+n([
+  o(String, { name: "callId" })
+], I.prototype, "id", 2);
+n([
+  o(String)
+], I.prototype, "pluginName", 2);
+n([
+  o(String)
+], I.prototype, "functionName", 2);
+n([
+  o(Ft)
+], I.prototype, "result", 2);
+n([
+  o(v)
+], I.prototype, "presentation", 2);
+n([
+  o(String)
+], I.prototype, "clientOutput", 2);
+I = n([
+  d({ name: "StreamingFinalFunctionResultContent" })
+], I);
+var X;
+let mt = (X = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "data");
+  }
+}, l(X, "FunctionClientOutputContent"), X);
+n([
+  o(String, { name: "callId" })
+], mt.prototype, "id", 2);
+n([
+  o(String)
+], mt.prototype, "data", 2);
+mt = n([
+  d({ name: "FunctionClientOutputContent" })
+], mt);
+var Z;
+let gt = (Z = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "clientOutput");
+  }
+}, l(Z, "StreamingClientOutputContent"), Z);
+n([
+  o(String, { name: "callId" })
+], gt.prototype, "id", 2);
+n([
+  o(String)
+], gt.prototype, "clientOutput", 2);
+gt = n([
+  d({ name: "StreamingClientOutputContent" })
+], gt);
+var j;
+let dt = (j = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "name");
+    e(this, "args");
+  }
+}, l(j, "UserUiContent"), j);
+n([
+  o(String)
+], dt.prototype, "name", 2);
+n([
+  o(String)
+], dt.prototype, "args", 2);
+dt = n([
+  d({ name: "UserUiContent" })
+], dt);
+var tt;
+let yt = (tt = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "role");
+    e(this, "items");
+  }
+}, l(tt, "ChatMessageContent"), tt);
+n([
+  o(Tt)
+], yt.prototype, "role", 2);
+n([
+  ft(() => h)
+], yt.prototype, "items", 2);
+yt = n([
+  d({ name: "ChatMessageContent" })
+], yt);
+var et;
+let O = (et = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "callId");
+    e(this, "name");
+    e(this, "arguments");
+    e(this, "functionCallIndex", 0);
+  }
+}, l(et, "StreamingFunctionCallUpdateContent"), et);
+n([
+  o(String)
+], O.prototype, "callId", 2);
+n([
+  o(String)
+], O.prototype, "name", 2);
+n([
+  o(String)
+], O.prototype, "arguments", 2);
+n([
+  o(Number)
+], O.prototype, "functionCallIndex", 2);
+O = n([
+  d({ name: "StreamingFunctionCallUpdateContent" })
+], O);
+var nt;
+let Ct = (nt = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "text");
+    // Encoding is not explicitly serialized in C#
+    // Not decorated with @jsonMember
+    e(this, "encoding");
+  }
+}, l(nt, "StreamingTextContent"), nt);
+n([
+  o(String)
+], Ct.prototype, "text", 2);
+Ct = n([
+  d({ name: "StreamingTextContent" })
+], Ct);
+var it;
+let Dt = (it = class extends C {
+  constructor() {
+    super(...arguments);
+    e(this, "text");
+    // Encoding is not explicitly serialized in C#
+    // Not decorated with @jsonMember
+    e(this, "encoding");
+  }
+}, l(it, "StreamingReasoningContent"), it);
+n([
+  o(String)
+], Dt.prototype, "text", 2);
+Dt = n([
+  d({ name: "StreamingReasoningContent" })
+], Dt);
+var ot;
+let k = (ot = class {
+  constructor() {
+    e(this, "instructionCategory", "");
+    e(this, "description", "");
+    e(this, "interactionId", "");
+  }
+}, l(ot, "InstructionSummary"), ot);
+n([
+  o(String)
+], k.prototype, "instructionCategory", 2);
+n([
+  o(String)
+], k.prototype, "description", 2);
+n([
+  o(String)
+], k.prototype, "interactionId", 2);
+k = n([
+  d({ name: "InstructionSummary" })
+], k);
+var rt;
+let E = (rt = class {
+  constructor() {
+    e(this, "size", 0);
+    e(this, "originalSize", 0);
+    e(this, "ratio", 0);
+    e(this, "previousRatio", 0);
+    e(this, "threshold", 0);
+    e(this, "maxSize", 0);
+    e(this, "id");
+    e(this, "instructionSummaries", []);
+  }
+}, l(rt, "SessionInformation"), rt);
+n([
+  o(Number)
+], E.prototype, "size", 2);
+n([
+  o(Number)
+], E.prototype, "originalSize", 2);
+n([
+  o(Number)
+], E.prototype, "ratio", 2);
+n([
+  o(Number)
+], E.prototype, "previousRatio", 2);
+n([
+  o(Number)
+], E.prototype, "threshold", 2);
+n([
+  o(Number)
+], E.prototype, "maxSize", 2);
+n([
+  o(String)
+], E.prototype, "id", 2);
+n([
+  ft(k)
+], E.prototype, "instructionSummaries", 2);
+E = n([
+  d({ name: "SessionInformation" })
+], E);
+var at;
+let S = (at = class {
+  constructor() {
+    e(this, "timestamp");
+    e(this, "mimeType");
+    e(this, "partial");
+    e(this, "turnComplete");
+    e(this, "visible");
+    e(this, "serverError");
+    e(this, "interactionId");
+    e(this, "sessionInformation");
+    e(this, "eventType");
+    e(this, "artifactsGenerated", []);
+    e(this, "author");
+    e(this, "role");
+    e(this, "command");
+    e(this, "content");
+    e(this, "streamingParts");
+    e(this, "subAgentId");
+    e(this, "subAgentName");
+    e(this, "text");
+  }
+}, l(at, "LlmEvent"), at);
+n([
+  o(Number)
+], S.prototype, "timestamp", 2);
+n([
+  o(String)
+], S.prototype, "mimeType", 2);
+n([
+  o(Boolean)
+], S.prototype, "partial", 2);
+n([
+  o(Boolean)
+], S.prototype, "turnComplete", 2);
+n([
+  o(Boolean)
+], S.prototype, "visible", 2);
+n([
+  o(String)
+], S.prototype, "serverError", 2);
+n([
+  o(String)
+], S.prototype, "interactionId", 2);
+n([
+  o(E)
+], S.prototype, "sessionInformation", 2);
+n([
+  o(ut)
+], S.prototype, "eventType", 2);
+n([
+  ft(R)
+], S.prototype, "artifactsGenerated", 2);
+n([
+  o(String)
+], S.prototype, "author", 2);
+n([
+  o(Tt)
+], S.prototype, "role", 2);
+n([
+  o(String)
+], S.prototype, "command", 2);
+n([
+  o(yt)
+], S.prototype, "content", 2);
+n([
+  ft(() => C)
+], S.prototype, "streamingParts", 2);
+S = n([
+  d({ name: "LlmEvent" })
+], S);
+var st;
+let D = (st = class {
+  constructor() {
+    e(this, "timeStamp");
+    e(this, "partialText");
+    e(this, "partialReasoning");
+    e(this, "functionName");
+    e(this, "streamingParts");
+    e(this, "functionCallId");
+    e(this, "type");
+    e(this, "iteractionId");
+    e(this, "partialEventType");
+    e(this, "subAgentId");
+  }
+}, l(st, "PartialLlmEvent"), st);
+n([
+  o(Number, { name: "ts" })
+], D.prototype, "timeStamp", 2);
+n([
+  o(String, { name: "pt" })
+], D.prototype, "partialText", 2);
+n([
+  o(String, { name: "pr" })
+], D.prototype, "partialReasoning", 2);
+n([
+  o(String, { name: "fn" })
+], D.prototype, "functionName", 2);
+n([
+  ft(() => C)
+], D.prototype, "streamingParts", 2);
+n([
+  o(String, { name: "fid" })
+], D.prototype, "functionCallId", 2);
+n([
+  o(String, { name: "tp" })
+], D.prototype, "type", 2);
+n([
+  o(String, { name: "itid" })
+], D.prototype, "iteractionId", 2);
+n([
+  o(ut)
+], D.prototype, "partialEventType", 2);
+n([
+  o(String, { name: "said" })
+], D.prototype, "subAgentId", 2);
+D = n([
+  d({ name: "PartialLlmEvent" })
+], D);
+var pt;
+let F = (pt = class {
+  constructor() {
+    e(this, "type");
+    e(this, "event");
+    e(this, "sessionId");
+    e(this, "accessToken");
+    e(this, "partialEvent");
+    e(this, "subAgentId");
+    e(this, "subAgentName");
+    e(this, "seq");
+  }
+}, l(pt, "StreamingResponse"), pt);
+n([
+  o(String)
+], F.prototype, "type", 2);
+n([
+  o(S)
+], F.prototype, "event", 2);
+n([
+  o(String)
+], F.prototype, "sessionId", 2);
+n([
+  o(String)
+], F.prototype, "accessToken", 2);
+n([
+  o(D, { name: "pe" })
+], F.prototype, "partialEvent", 2);
+n([
+  o(String)
+], F.prototype, "subAgentId", 2);
+n([
+  o(String)
+], F.prototype, "subAgentName", 2);
+n([
+  o(Number)
+], F.prototype, "seq", 2);
+F = n([
+  d({ name: "StreamingResponse" })
+], F);
+var lt;
+let At = (lt = class {
+  constructor() {
+    e(this, "events");
+  }
+}, l(lt, "Payload"), lt);
+n([
+  ft(S)
+], At.prototype, "events", 2);
+At = n([
+  d({ name: "Payload" })
+], At);
+function Bt(s) {
+  var a;
+  const t = (s == null ? void 0 : s.presentation) ?? ((a = s == null ? void 0 : s.metadata) == null ? void 0 : a[Mt]);
+  if (!t || typeof t != "object") return { isUi: !1 };
+  const i = t, r = /* @__PURE__ */ l((p, c) => i[p] ?? i[c], "pick");
+  return {
+    isUi: r("isUi", "IsUi") === !0,
+    askUserComponent: r("askUserComponent", "AskUserComponent") || void 0,
+    argsDescription: r("argsDescription", "ArgsDescription") || void 0
+  };
+}
+l(Bt, "readPresentation");
+const N = class N {
+  constructor(t) {
+    e(this, "uniqueId");
+    e(this, "mimeType");
+    e(this, "created");
+    e(this, "author");
+    e(this, "eventType");
+    e(this, "allEventTypes", []);
+    e(this, "interactionId");
+    e(this, "artifactsDelta", []);
+    e(this, "llmArtifacts", []);
+    e(this, "partial");
+    e(this, "turn_complete");
+    e(this, "isFinalResponse");
+    e(this, "interrupted");
+    e(this, "model_session_id");
+    e(this, "functionDetails");
+    e(this, "executableCodeDetails");
+    e(this, "codeExecutionResultDetails");
+    e(this, "thoughtDefails");
+    e(this, "rawDetails");
+    e(this, "rendered");
+    e(this, "serverError");
+    e(this, "server_session_id");
+    e(this, "asyncFinalResponse");
+    e(this, "agentServerBaseUrl");
+    e(this, "parts", []);
+    e(this, "endMessageData");
+    e(this, "command");
+    e(this, "session_information");
+    e(this, "subAgentId");
+    e(this, "subAgentName");
+    e(this, "visible", !0);
+    this.interactionId = t, this.author = "main";
+  }
+  static createErrorEvent(t, i) {
+    const r = new N(i);
+    r.turn_complete = !0, r.partial = !1, r.parts = [];
+    const a = {
+      eventType: m.ServerError,
+      errorDetails: {
+        errorMessage: t
+      },
+      id: "",
+      author: "main",
+      created: /* @__PURE__ */ new Date(),
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1
+    };
+    return r.parts.push(a), r;
+  }
+  static parseFlatPropertiesTypedEvent(t) {
+    var r, a, p;
+    const i = new N(t.interactionId);
+    if (i.serverError = t.serverError, !t.interactionId)
+      throw new Error("Interaction ID is required");
+    switch (i.model_session_id = "", i.server_session_id = null, i.asyncFinalResponse = t.turnComplete, i.command = (r = t.command) == null ? void 0 : r.toString(), t.sessionInformation && (i.session_information = t.sessionInformation), (!t.author || t.author == "") && console.warn('[ServerEvent] event with no author; defaulting to "main"', {
+      interactionId: t.interactionId,
+      turnComplete: t.turnComplete
+    }), t == null ? void 0 : t.author) {
+      case Wt:
+        i.author = "tool";
+        break;
+      case "system":
+        i.author = "system";
+        break;
+      default:
+        i.author = "main";
+    }
+    return i.mimeType = t.mimeType, i.created = new Date(t.timestamp), i.eventType = m.NotDefined, i.partial = ((p = (a = t.partial) == null ? void 0 : a.toString()) == null ? void 0 : p.toLowerCase()) === "true", i.turn_complete = t.turnComplete, i.visible = t.visible, i.isFinalResponse = t.turnComplete ?? !1, i.artifactsDelta = [], t.artifactsGenerated && t.artifactsGenerated.length > 0 && (i.created = new Date(t.timestamp), i.llmArtifacts = t.artifactsGenerated), i.subAgentId = t.subAgentId, i.subAgentName = t.subAgentName, i;
+  }
+  static getPartType(t) {
+    return t instanceof xt ? "TextContent" : t instanceof A ? "FunctionCallContent" : t instanceof U ? "FunctionResultContent" : t instanceof O ? "StreamingFunctionCallUpdateContent" : t instanceof b ? "StreamingFinalFunctionCallContent" : t instanceof I ? "StreamingFinalFunctionResultContent" : t instanceof mt ? "FunctionClientOutputContent" : t instanceof gt ? "StreamingClientOutputContent" : t instanceof dt ? "UserUiContent" : t instanceof Ct ? "StreamingTextContent" : t instanceof Dt ? "StreamingReasoningContent" : t instanceof P ? "ToolEventContent" : t instanceof ct ? "StreamingToolEventContent" : "Unknown";
+  }
+  static parseFromTypedEvent(t) {
+    var p, c, g, z, bt, Ut, Ot;
+    const i = N.parseFlatPropertiesTypedEvent(t);
+    if (i.serverError)
+      return i.parts.push(Nt.fromError(i.serverError)), i;
+    if (!t.content && !t.streamingParts)
+      return i;
+    i.parts = [];
+    const r = [...((p = t.content) == null ? void 0 : p.items) ?? [], ...t.streamingParts ?? []];
+    i.eventType = $t(((c = t.eventType) == null ? void 0 : c.type) ?? "");
+    for (const f of r) {
+      let u = {
+        id: "",
+        author: i.author,
+        eventType: i.eventType,
+        created: /* @__PURE__ */ new Date(),
+        visible: i.visible,
+        partial: i.partial,
+        isStillWriting: !1,
+        mustPush: !1,
+        textAppendable: !1
+      };
+      const T = N.getPartType(f);
+      if (T == x.FunctionCallContent || T == x.FunctionResultContent || T == x.StreamingFinalFunctionCallContent || T == x.StreamingFinalFunctionResultContent) {
+        var a = f;
+        if (a.id == "Server Error")
+          u.eventType = m.ServerError, u.errorDetails = {
+            errorMessage: JSON.stringify(a.arguments)
+          }, u.functionDetails = void 0;
+        else {
+          u.eventType = T == x.FunctionCallContent || T == x.StreamingFinalFunctionCallContent ? m.FunctionCall : m.FunctionResponse;
+          let y;
+          try {
+            if (a != null && a.result)
+              if (typeof a.result == "object")
+                y = a.result;
+              else if (typeof a.result == "string") {
+                const St = JSON.parse(a.result);
+                y = typeof St == "object" && St !== null ? St : a.result;
+              } else
+                y = a.result;
+          } catch (St) {
+            console.warn("Parse function error", St), y = a == null ? void 0 : a.result;
+          }
+          u.thoughtDetails = {
+            text: ""
+          };
+          const It = Bt(a);
+          u.functionDetails = {
+            id: (a == null ? void 0 : a.id) ?? "",
+            args: a == null ? void 0 : a.arguments,
+            start: T == x.FunctionCallContent ? i.created : void 0,
+            end: T == x.FunctionResultContent ? i.created : void 0,
+            text: JSON.stringify(a == null ? void 0 : a.arguments) ?? "",
+            name: (a == null ? void 0 : a.functionName) ?? "",
+            status: u.eventType == m.FunctionCall ? "Executing" : "Done",
+            response: y,
+            isUi: It.isUi,
+            argsDescription: It.argsDescription,
+            // Client-only payload riding the RESULT event: live top-level `clientOutput`, or
+            // metadata.clientOutput on the collapsed/persisted result. Calls leave it undefined.
+            // The persisted-replay form also folds in via FunctionClientOutputContent.
+            clientOutput: (a == null ? void 0 : a.clientOutput) ?? ((g = a == null ? void 0 : a.metadata) == null ? void 0 : g.clientOutput),
+            askUserComponent: It.askUserComponent
+          }, u.functionDetails.isAskUser = !!u.functionDetails.askUserComponent, t.text = a == null ? void 0 : a.arguments;
+        }
+      } else if (T == x.StreamingTextContent)
+        u.eventType = m.Text, u.text = (z = f == null ? void 0 : f.text) == null ? void 0 : z.replaceAll("\\n", `
+`), u.textLastChunk = f.text, t.text = u.text;
+      else if (T == x.TextContent)
+        u.eventType = m.Text, u.text = (bt = f == null ? void 0 : f.text) == null ? void 0 : bt.replaceAll("\\n", `
+`), u.textLastChunk = f.text, t.text = u.text;
+      else if (T == x.StreamingReasoningContent)
+        u.eventType = m.Thought, u.thoughtDetails = {
+          text: ((Ut = f == null ? void 0 : f.text) == null ? void 0 : Ut.replaceAll("\\n", `
+`)) ?? ""
+        }, u.text = (Ot = f == null ? void 0 : f.text) == null ? void 0 : Ot.replaceAll("\\n", `
+`), u.textLastChunk = f.text, t.text = u.text;
+      else if (T == x.StreamingFunctionCallUpdateContent) {
+        const y = f;
+        u.eventType = m.PartialFunctionCall, u.text = y.arguments, u.thoughtDetails = {
+          text: ""
+        }, u.functionDetails = {
+          id: y.callId ?? "",
+          text: u.text,
+          status: "Composing",
+          name: (y == null ? void 0 : y.name) ?? "Unknown"
+        }, t.text = u.text;
+      } else if (T == x.ToolEventContent || T == x.StreamingToolEventContent) {
+        u.eventType = m.ToolEvent;
+        const y = f;
+        u.toolDetails = {
+          eventName: y.eventName ?? "",
+          eventData: y.eventData ?? "",
+          sessionId: y.sessionId ?? void 0
+        };
+      } else if (T == x.FunctionClientOutputContent) {
+        const y = f;
+        u.eventType = m.FunctionClientOutput, u.functionDetails = {
+          id: y.id ?? "",
+          name: "",
+          status: "Done",
+          clientOutput: y.data
+        };
+      } else if (T == x.StreamingClientOutputContent) {
+        const y = f;
+        u.eventType = m.FunctionClientOutput, u.functionDetails = {
+          id: y.id ?? "",
+          name: "",
+          // The parked call stays Executing; interactionService folds only clientOutput onto it and
+          // leaves the existing status untouched, so this is just to satisfy the type.
+          status: "Executing",
+          clientOutput: y.clientOutput
+        };
+      } else if (T == x.UserUiContent) {
+        const y = f;
+        u.eventType = m.UserAnswer, u.author = "user", u.functionDetails = {
+          id: "",
+          name: y.name ?? "",
+          args: y.args,
+          status: "Done",
+          isUi: !0
+        };
+      } else {
+        u.eventType = m.NotDefined, console.warn(`Got a unmapped event_type:${i.eventType}, data:`, T, f);
+        continue;
+      }
+      i.parts.push(u);
+    }
+    return i;
+  }
+  static createFromThought(t, i) {
+    return {
+      author: "main",
+      visible: !0,
+      eventType: m.Thought,
+      uniqueId: (/* @__PURE__ */ new Date()).getTime().toString(),
+      interactionId: t,
+      allEventTypes: [m.Thought],
+      artifactsDelta: [""],
+      model_session_id: "",
+      created: /* @__PURE__ */ new Date(),
+      turn_complete: !1,
+      partial: !0,
+      asyncFinalResponse: !1,
+      mimeType: "text/plain",
+      parts: [
+        {
+          thoughtDetails: {
+            text: i
+          },
+          id: Et(),
+          created: /* @__PURE__ */ new Date(),
+          eventType: m.Thought,
+          author: "main",
+          isStillWriting: !1,
+          textAppendable: !0,
+          partial: !0,
+          mustPush: !0
+        }
+      ]
+    };
+  }
+  static createFromFunctionName(t, i, r) {
+    const a = N.createFromText("", i);
+    return a.parts[0].text = void 0, a.parts[0].thoughtDetails = void 0, a.parts[0].textAppendable = !1, a.parts[0].mustPush = !0, a.parts[0].functionDetails = {
+      name: t,
+      id: "callId",
+      status: "Executing",
+      start: /* @__PURE__ */ new Date(),
+      end: void 0,
+      text: "dfsdfdf",
+      args: r
+    }, a;
+  }
+  static createFromText(t, i, r) {
+    return {
+      author: "main",
+      visible: !0,
+      eventType: m.Text,
+      uniqueId: (/* @__PURE__ */ new Date()).getTime().toString(),
+      interactionId: i,
+      allEventTypes: [m.Text],
+      artifactsDelta: [""],
+      model_session_id: "",
+      created: /* @__PURE__ */ new Date(),
+      turn_complete: !1,
+      partial: !0,
+      asyncFinalResponse: !1,
+      mimeType: "text/plain",
+      parts: [
+        {
+          // Optional reasoning trace shown next to the message. Parts
+          // with `eventType: Text` AND a populated `thoughtDetails`
+          // render the text in the body and the trace in the
+          // thinking strip.
+          thoughtDetails: r ? {
+            text: r
+          } : void 0,
+          id: Et(),
+          created: /* @__PURE__ */ new Date(),
+          // Part eventType MUST match the outer event's eventType.
+          // Was previously `Thought` here, which made the merger
+          // classify a streamed Text part as a Thought (rendered
+          // in the trace strip instead of the message body) —
+          // the chat would show the message during streaming and
+          // then "disappear" once the part was reclassified.
+          eventType: m.Text,
+          author: "main",
+          isStillWriting: !1,
+          textAppendable: !0,
+          partial: !0,
+          mustPush: !0,
+          text: t
+        }
+      ]
+    };
+  }
+};
+l(N, "ServerEvent");
+let Rt = N;
+const vt = [
+  // KernelContent derived types
+  xt,
+  ht,
+  A,
+  P,
+  U,
+  mt,
+  dt,
+  yt,
+  // StreamingKernelContent derived types
+  Ct,
+  O,
+  Dt,
+  b,
+  I,
+  gt,
+  k
+];
+function Kt(s) {
+  return s.name;
+}
+l(Kt, "getConstructorName");
+function kt(s, t, i, r) {
+  t.constructor !== i && (s.$type = (r == null ? void 0 : r.name) ?? Kt(t.constructor));
+}
+l(kt, "dotNetTypeEmitter");
+function zt(s, t) {
+  if (s.$type != null)
+    return t.get(s.$type);
+}
+l(zt, "dotnetTypeResolver");
+function _t() {
+  const s = new Pt(S);
+  return s.config({
+    knownTypes: vt,
+    typeHintEmitter: kt,
+    typeResolver: zt
+  }), s;
+}
+l(_t, "createEventSerializer");
+function Ht() {
+  const s = new Pt(F);
+  return s.config({
+    knownTypes: vt,
+    typeHintEmitter: kt,
+    typeResolver: zt
+  }), s;
+}
+l(Ht, "createStreamingResponseSerializer");
+function Lt(s) {
+  try {
+    return JSON.parse(s), s;
+  } catch {
+    let i = "", r = !1;
+    for (let a = 0; a < s.length; a++) {
+      const p = s[a], c = p.charCodeAt(0);
+      if (p === "\\" && r && a + 1 < s.length) {
+        const g = s[a + 1];
+        if (g === '"' || g === "\\" || g === "/" || g === "b" || g === "f" || g === "n" || g === "r" || g === "t") {
+          i += p + g, a++;
+          continue;
+        } else if (g === "u" && a + 5 < s.length) {
+          i += s.substring(a, a + 6), a += 5;
+          continue;
+        } else {
+          i += p;
+          continue;
+        }
+      }
+      if (p === '"') {
+        let g = 0;
+        for (let z = a - 1; z >= 0 && s[z] === "\\"; z--)
+          g++;
+        g % 2 === 0 && (r = !r), i += p;
+        continue;
+      }
+      if (r && c < 32)
+        switch (p) {
+          case `
+`:
+            i += "\\n";
+            break;
+          case "\r":
+            i += "\\r";
+            break;
+          case "	":
+            i += "\\t";
+            break;
+          case "\f":
+            i += "\\f";
+            break;
+          case "\b":
+            i += "\\b";
+            break;
+          default:
+            const g = c.toString(16).padStart(4, "0");
+            i += `\\u${g}`;
+            break;
+        }
+      else
+        i += p;
+    }
+    return i;
+  }
+}
+l(Lt, "sanitizeJsonString");
+function Xt(s) {
+  const t = Lt(s);
+  return Ht().parse(t);
+}
+l(Xt, "deserializePayload");
+function Zt(s) {
+  const t = Lt(s);
+  return _t().parse(t);
+}
+l(Zt, "deserializeEvent");
+function jt(s) {
+  return _t().stringify(s);
+}
+l(jt, "serializeEvent");
+export {
+  yt as C,
+  A as F,
+  Nt as I,
+  S as L,
+  x as P,
+  Rt as S,
+  xt as T,
+  U as a,
+  O as b,
+  Dt as c,
+  F as d,
+  Ct as e,
+  _t as f,
+  Ht as g,
+  Zt as h,
+  Xt as i,
+  jt as j,
+  Lt as s
+};
+//# sourceMappingURL=serializer-BPina6fX.js.map