@aintela/chat 0.2.15

package/dist/serializer-DyHZxlAG.js

@@ -0,0 +1,1276 @@
+var It = Object.defineProperty;
+var _t = (p, t, i) => t in p ? It(p, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : p[t] = i;
+var u = (p, t) => It(p, "name", { value: t, configurable: !0 });
+var e = (p, t, i) => _t(p, typeof t != "symbol" ? t + "" : t, i);
+import { E as l, q as xt, A as zt, G as vt } from "./environmentUtils-BaKw5_VD.js";
+import { jsonMember as r, jsonObject as g, AnyT as ht, jsonArrayMember as mt, TypedJSON as At } from "typedjson";
+const P = class P {
+  static replaceFirstTwoTabsPerLine(t) {
+    const i = /^\s{15}/gm;
+    return typeof t == "string" ? t.replaceAll(i, (a) => a.substring(15)) : t ?? "";
+  }
+  static jsonToString(t) {
+    if (t == null) return "";
+    if (typeof t != "object") return String(t);
+    const i = Array.isArray(t) ? P.isCharArray(t) ? t.join("") : null : P.tryCollapseCharIndexedObject(t);
+    if (i != null) return i;
+    if (Array.isArray(t))
+      try {
+        return JSON.stringify(t, null, 2);
+      } catch {
+        return String(t);
+      }
+    const a = Object.keys(t), o = [];
+    return a.forEach((s) => {
+      let m = t[s];
+      typeof m == "object" && (m = JSON.stringify(t[s], null, 2));
+      const f = (m == null ? void 0 : m.toString().indexOf(`
+`)) > -1 ? `
+` : "";
+      o.push(`${s}:${f}${m}`);
+    }), o.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), a = [];
+    return i.forEach((o) => {
+      let s = t == null ? void 0 : t[o];
+      typeof s == "object" && (s = JSON.stringify(s, null, 2));
+      const m = (s == null ? void 0 : s.toString().indexOf(`
+`)) > -1 ? `
+` : "";
+      a.push(`${o}:${m}${s}`);
+    }), a.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 s;
+    let i = (s = t == null ? void 0 : t.functionDetails) == null ? void 0 : s.response;
+    for (let m = 0; m < 2 && typeof i == "string"; m++)
+      try {
+        i = JSON.parse(i);
+      } catch {
+        return;
+      }
+    if (!i || typeof i != "object") return;
+    const a = i, o = a.SlotId ?? a.slotId;
+    return typeof o == "string" ? o : void 0;
+  }
+  static fromError(t) {
+    return {
+      errorDetails: { errorMessage: t },
+      eventType: l.ServerError,
+      id: "",
+      author: "main",
+      created: /* @__PURE__ */ new Date(),
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1
+    };
+  }
+  static fromText(t, i, a) {
+    return {
+      text: t,
+      eventType: l.Text,
+      id: a ?? xt(),
+      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, a) {
+    return {
+      id: a ?? xt(),
+      eventType: l.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, a, o, s) {
+    a || (a = "Waiting");
+    const m = P.fromText("...", void 0, "waitingpart");
+    return m.eventType = l.Waiting, m.waitingDetails = {
+      startingPoint: o,
+      addTimer: t,
+      isTimerRunning: i,
+      status: a,
+      stopPoint: s
+    }, m;
+  }
+  static createSuspended() {
+    const t = P.fromText("SUSPEND");
+    return t.eventType = l.Suspended, t;
+  }
+  static getPartTextContent(t) {
+    return t.text ?? "";
+  }
+  static FlatParts(t) {
+    if (t.length === 0)
+      return;
+    const i = t.filter((s) => s.eventType == l.Text), a = i.length > 0 ? i[0] : t[0], o = [...new Set(t.map((s) => s.eventType))];
+    o.length == 1 ? a.eventType = o[0] : i.length > 0 && (a.eventType = l.Text), a.mustPush = !(a.eventType == l.Text || a.eventType == l.Thought || a.eventType == l.NotDefined || a.eventType == l.PartialFunctionCall), a.textAppendable = a.eventType == l.Text || a.eventType == l.Thought || a.eventType == l.PartialFunctionCall;
+    for (const s of t)
+      !a.codeExecutionResultDetails && s.codeExecutionResultDetails && (a.codeExecutionResultDetails = s.codeExecutionResultDetails), !a.errorDetails && s.errorDetails && (a.errorDetails = s.errorDetails), !a.executableCodeDetails && s.executableCodeDetails && (a.executableCodeDetails = s.executableCodeDetails), !a.functionDetails && s.functionDetails && (a.functionDetails = s.functionDetails), !a.rawDetails && s.rawDetails && (a.rawDetails = s.rawDetails), !a.thoughtDetails && s.thoughtDetails && (a.thoughtDetails = s.thoughtDetails), !a.errorDetails && s.errorDetails && (a.errorDetails = s.errorDetails);
+    return a;
+  }
+  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 a = 0; a < i.length; a++) {
+      if (i[a] !== String(a)) return null;
+      const o = t[i[a]];
+      if (typeof o != "string" || o.length !== 1) return null;
+    }
+    return i.map((a) => t[a]).join("");
+  }
+  static isCodeExecution(t) {
+    return t.eventType === l.CodeExecutionResult || t.eventType === l.ExecutableCode;
+  }
+};
+u(P, "InteractionPartUtils");
+let Dt = P;
+var kt = Object.defineProperty, Lt = Object.getOwnPropertyDescriptor, n = /* @__PURE__ */ u((p, t, i, a) => {
+  for (var o = a > 1 ? void 0 : a ? Lt(t, i) : t, s = p.length - 1, m; s >= 0; s--)
+    (m = p[s]) && (o = (a ? m(t, i, o) : m(o)) || o);
+  return a && o && kt(t, i, o), o;
+}, "__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"
+};
+var v;
+let yt = (v = class {
+  constructor() {
+    e(this, "label");
+  }
+}, u(v, "AuthorRole"), v);
+n([
+  r(String)
+], yt.prototype, "label", 2);
+yt = n([
+  g({ name: "AuthorRole" })
+], yt);
+var k;
+let st = (k = class {
+  constructor() {
+    e(this, "type");
+    e(this, "fullName");
+  }
+}, u(k, "EventTypeInformation"), k);
+n([
+  r(String)
+], st.prototype, "type", 2);
+n([
+  r(String)
+], st.prototype, "fullName", 2);
+st = n([
+  g({ name: "EventTypeInformation" })
+], st);
+var L;
+let U = (L = 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
+    };
+  }
+}, u(L, "LlmArtifact"), L);
+n([
+  r(String)
+], U.prototype, "id", 2);
+n([
+  r(String)
+], U.prototype, "name", 2);
+n([
+  r(String)
+], U.prototype, "mimeType", 2);
+n([
+  r(String)
+], U.prototype, "description", 2);
+U = n([
+  g({ name: "LlmArtifact" })
+], U);
+var J;
+let h = (J = class {
+  constructor() {
+    e(this, "mimeType");
+    // InnerContent is ignored (JsonIgnore in C#)
+    // Not decorated with @jsonMember
+    e(this, "innerContent");
+    e(this, "modelId");
+    e(this, "metadata");
+  }
+}, u(J, "KernelContent"), J);
+n([
+  r(String)
+], h.prototype, "mimeType", 2);
+n([
+  r(String)
+], h.prototype, "modelId", 2);
+n([
+  r(ht)
+], h.prototype, "metadata", 2);
+h = n([
+  g({ name: "KernelContent" })
+], h);
+var W;
+let D = (W = 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");
+  }
+}, u(W, "StreamingKernelContent"), W);
+n([
+  r(Number)
+], D.prototype, "choiceIndex", 2);
+n([
+  r(String)
+], D.prototype, "modelId", 2);
+n([
+  r(Object)
+], D.prototype, "metadata", 2);
+D = n([
+  g({ name: "StreamingKernelContent" })
+], D);
+var $;
+let dt = ($ = 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 ?? "";
+  }
+}, u($, "TextContent"), $);
+n([
+  r(String)
+], dt.prototype, "text", 2);
+dt = n([
+  g({ name: "TextContent" })
+], dt);
+var G;
+let pt = (G = class extends D {
+  constructor() {
+    super();
+    e(this, "eventName");
+    e(this, "eventData");
+    e(this, "sessionId");
+  }
+}, u(G, "StreamingToolEventContent"), G);
+n([
+  r(String)
+], pt.prototype, "eventName", 2);
+n([
+  r(String)
+], pt.prototype, "eventData", 2);
+n([
+  r(String)
+], pt.prototype, "sessionId", 2);
+pt = n([
+  g({ name: "StreamingToolEventContent" })
+], pt);
+var q;
+let O = (q = class extends h {
+  constructor() {
+    super();
+    e(this, "eventName");
+    e(this, "eventData");
+    e(this, "sessionId");
+  }
+}, u(q, "ToolEventContent"), q);
+n([
+  r(String)
+], O.prototype, "eventName", 2);
+n([
+  r(String)
+], O.prototype, "eventData", 2);
+n([
+  r(String)
+], O.prototype, "sessionId", 2);
+O = n([
+  g({ name: "ToolEventContent" })
+], O);
+var B;
+let ft = (B = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "url");
+    e(this, "dataUri");
+  }
+}, u(B, "ImageContent"), B);
+n([
+  r(String)
+], ft.prototype, "url", 2);
+n([
+  r(String)
+], ft.prototype, "dataUri", 2);
+ft = n([
+  g({ name: "ImageContent" })
+], ft);
+var M;
+let A = (M = 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");
+  }
+}, u(M, "FunctionCallContent"), M);
+n([
+  r(String)
+], A.prototype, "id", 2);
+n([
+  r(String)
+], A.prototype, "pluginName", 2);
+n([
+  r(String)
+], A.prototype, "functionName", 2);
+n([
+  r(ht)
+], A.prototype, "arguments", 2);
+A = n([
+  g({ name: "FunctionCallContent" })
+], A);
+var K;
+let I = (K = class extends D {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "functionName");
+    e(this, "arguments");
+    e(this, "isUi");
+    e(this, "friendlyArgsDescription");
+  }
+}, u(K, "StreamingFinalFunctionCallContent"), K);
+n([
+  r(String, { name: "callId" })
+], I.prototype, "id", 2);
+n([
+  r(String, { name: "name" })
+], I.prototype, "functionName", 2);
+n([
+  r(String)
+], I.prototype, "arguments", 2);
+n([
+  r(Boolean)
+], I.prototype, "isUi", 2);
+n([
+  r(String)
+], I.prototype, "friendlyArgsDescription", 2);
+I = n([
+  g({ name: "StreamingFinalFunctionCallContent" })
+], I);
+var H;
+let R = (H = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "pluginName");
+    e(this, "functionName");
+    e(this, "result");
+  }
+}, u(H, "FunctionResultContent"), H);
+n([
+  r(String, { name: "callId" })
+], R.prototype, "id", 2);
+n([
+  r(String)
+], R.prototype, "pluginName", 2);
+n([
+  r(String)
+], R.prototype, "functionName", 2);
+n([
+  r(ht)
+], R.prototype, "result", 2);
+R = n([
+  g({ name: "FunctionResultContent" })
+], R);
+var Y;
+let N = (Y = class extends D {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "pluginName");
+    e(this, "functionName");
+    e(this, "result");
+    e(this, "isUi");
+    e(this, "clientOutput");
+  }
+}, u(Y, "StreamingFinalFunctionResultContent"), Y);
+n([
+  r(String, { name: "callId" })
+], N.prototype, "id", 2);
+n([
+  r(String)
+], N.prototype, "pluginName", 2);
+n([
+  r(String)
+], N.prototype, "functionName", 2);
+n([
+  r(ht)
+], N.prototype, "result", 2);
+n([
+  r(Boolean)
+], N.prototype, "isUi", 2);
+n([
+  r(String)
+], N.prototype, "clientOutput", 2);
+N = n([
+  g({ name: "StreamingFinalFunctionResultContent" })
+], N);
+var Q;
+let ut = (Q = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "id");
+    e(this, "data");
+  }
+}, u(Q, "FunctionClientOutputContent"), Q);
+n([
+  r(String, { name: "callId" })
+], ut.prototype, "id", 2);
+n([
+  r(String)
+], ut.prototype, "data", 2);
+ut = n([
+  g({ name: "FunctionClientOutputContent" })
+], ut);
+var V;
+let lt = (V = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "name");
+    e(this, "args");
+  }
+}, u(V, "UserUiContent"), V);
+n([
+  r(String)
+], lt.prototype, "name", 2);
+n([
+  r(String)
+], lt.prototype, "args", 2);
+lt = n([
+  g({ name: "UserUiContent" })
+], lt);
+var X;
+let ct = (X = class extends h {
+  constructor() {
+    super(...arguments);
+    e(this, "role");
+    e(this, "items");
+  }
+}, u(X, "ChatMessageContent"), X);
+n([
+  r(yt)
+], ct.prototype, "role", 2);
+n([
+  mt(() => h)
+], ct.prototype, "items", 2);
+ct = n([
+  g({ name: "ChatMessageContent" })
+], ct);
+var Z;
+let w = (Z = class extends D {
+  constructor() {
+    super(...arguments);
+    e(this, "callId");
+    e(this, "name");
+    e(this, "arguments");
+    e(this, "functionCallIndex", 0);
+  }
+}, u(Z, "StreamingFunctionCallUpdateContent"), Z);
+n([
+  r(String)
+], w.prototype, "callId", 2);
+n([
+  r(String)
+], w.prototype, "name", 2);
+n([
+  r(String)
+], w.prototype, "arguments", 2);
+n([
+  r(Number)
+], w.prototype, "functionCallIndex", 2);
+w = n([
+  g({ name: "StreamingFunctionCallUpdateContent" })
+], w);
+var j;
+let St = (j = class extends D {
+  constructor() {
+    super(...arguments);
+    e(this, "text");
+    // Encoding is not explicitly serialized in C#
+    // Not decorated with @jsonMember
+    e(this, "encoding");
+  }
+}, u(j, "StreamingTextContent"), j);
+n([
+  r(String)
+], St.prototype, "text", 2);
+St = n([
+  g({ name: "StreamingTextContent" })
+], St);
+var tt;
+let Tt = (tt = class extends D {
+  constructor() {
+    super(...arguments);
+    e(this, "text");
+    // Encoding is not explicitly serialized in C#
+    // Not decorated with @jsonMember
+    e(this, "encoding");
+  }
+}, u(tt, "StreamingReasoningContent"), tt);
+n([
+  r(String)
+], Tt.prototype, "text", 2);
+Tt = n([
+  g({ name: "StreamingReasoningContent" })
+], Tt);
+var et;
+let _ = (et = class {
+  constructor() {
+    e(this, "instructionCategory", "");
+    e(this, "description", "");
+    e(this, "interactionId", "");
+  }
+}, u(et, "InstructionSummary"), et);
+n([
+  r(String)
+], _.prototype, "instructionCategory", 2);
+n([
+  r(String)
+], _.prototype, "description", 2);
+n([
+  r(String)
+], _.prototype, "interactionId", 2);
+_ = n([
+  g({ name: "InstructionSummary" })
+], _);
+var nt;
+let E = (nt = 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", []);
+  }
+}, u(nt, "SessionInformation"), nt);
+n([
+  r(Number)
+], E.prototype, "size", 2);
+n([
+  r(Number)
+], E.prototype, "originalSize", 2);
+n([
+  r(Number)
+], E.prototype, "ratio", 2);
+n([
+  r(Number)
+], E.prototype, "previousRatio", 2);
+n([
+  r(Number)
+], E.prototype, "threshold", 2);
+n([
+  r(Number)
+], E.prototype, "maxSize", 2);
+n([
+  r(String)
+], E.prototype, "id", 2);
+n([
+  mt(_)
+], E.prototype, "instructionSummaries", 2);
+E = n([
+  g({ name: "SessionInformation" })
+], E);
+var it;
+let S = (it = 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");
+  }
+}, u(it, "LlmEvent"), it);
+n([
+  r(Number)
+], S.prototype, "timestamp", 2);
+n([
+  r(String)
+], S.prototype, "mimeType", 2);
+n([
+  r(Boolean)
+], S.prototype, "partial", 2);
+n([
+  r(Boolean)
+], S.prototype, "turnComplete", 2);
+n([
+  r(Boolean)
+], S.prototype, "visible", 2);
+n([
+  r(String)
+], S.prototype, "serverError", 2);
+n([
+  r(String)
+], S.prototype, "interactionId", 2);
+n([
+  r(E)
+], S.prototype, "sessionInformation", 2);
+n([
+  r(st)
+], S.prototype, "eventType", 2);
+n([
+  mt(U)
+], S.prototype, "artifactsGenerated", 2);
+n([
+  r(String)
+], S.prototype, "author", 2);
+n([
+  r(yt)
+], S.prototype, "role", 2);
+n([
+  r(String)
+], S.prototype, "command", 2);
+n([
+  r(ct)
+], S.prototype, "content", 2);
+n([
+  mt(() => D)
+], S.prototype, "streamingParts", 2);
+S = n([
+  g({ name: "LlmEvent" })
+], S);
+var ot;
+let C = (ot = 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");
+  }
+}, u(ot, "PartialLlmEvent"), ot);
+n([
+  r(Number, { name: "ts" })
+], C.prototype, "timeStamp", 2);
+n([
+  r(String, { name: "pt" })
+], C.prototype, "partialText", 2);
+n([
+  r(String, { name: "pr" })
+], C.prototype, "partialReasoning", 2);
+n([
+  r(String, { name: "fn" })
+], C.prototype, "functionName", 2);
+n([
+  mt(() => D)
+], C.prototype, "streamingParts", 2);
+n([
+  r(String, { name: "fid" })
+], C.prototype, "functionCallId", 2);
+n([
+  r(String, { name: "tp" })
+], C.prototype, "type", 2);
+n([
+  r(String, { name: "itid" })
+], C.prototype, "iteractionId", 2);
+n([
+  r(st)
+], C.prototype, "partialEventType", 2);
+n([
+  r(String, { name: "said" })
+], C.prototype, "subAgentId", 2);
+C = n([
+  g({ name: "PartialLlmEvent" })
+], C);
+var rt;
+let F = (rt = 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");
+  }
+}, u(rt, "StreamingResponse"), rt);
+n([
+  r(String)
+], F.prototype, "type", 2);
+n([
+  r(S)
+], F.prototype, "event", 2);
+n([
+  r(String)
+], F.prototype, "sessionId", 2);
+n([
+  r(String)
+], F.prototype, "accessToken", 2);
+n([
+  r(C, { name: "pe" })
+], F.prototype, "partialEvent", 2);
+n([
+  r(String)
+], F.prototype, "subAgentId", 2);
+n([
+  r(String)
+], F.prototype, "subAgentName", 2);
+n([
+  r(Number)
+], F.prototype, "seq", 2);
+F = n([
+  g({ name: "StreamingResponse" })
+], F);
+var at;
+let Ct = (at = class {
+  constructor() {
+    e(this, "events");
+  }
+}, u(at, "Payload"), at);
+n([
+  mt(S)
+], Ct.prototype, "events", 2);
+Ct = n([
+  g({ name: "Payload" })
+], Ct);
+const b = class b {
+  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 a = new b(i);
+    a.turn_complete = !0, a.partial = !1, a.parts = [];
+    const o = {
+      eventType: l.ServerError,
+      errorDetails: {
+        errorMessage: t
+      },
+      id: "",
+      author: "main",
+      created: /* @__PURE__ */ new Date(),
+      partial: !1,
+      isStillWriting: !1,
+      mustPush: !1,
+      textAppendable: !1
+    };
+    return a.parts.push(o), a;
+  }
+  static parseFlatPropertiesTypedEvent(t) {
+    var a, o, s;
+    const i = new b(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 = (a = t.command) == null ? void 0 : a.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 zt:
+        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 = l.NotDefined, i.partial = ((s = (o = t.partial) == null ? void 0 : o.toString()) == null ? void 0 : s.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 dt ? "TextContent" : t instanceof A ? "FunctionCallContent" : t instanceof R ? "FunctionResultContent" : t instanceof w ? "StreamingFunctionCallUpdateContent" : t instanceof I ? "StreamingFinalFunctionCallContent" : t instanceof N ? "StreamingFinalFunctionResultContent" : t instanceof ut ? "FunctionClientOutputContent" : t instanceof lt ? "UserUiContent" : t instanceof St ? "StreamingTextContent" : t instanceof Tt ? "StreamingReasoningContent" : t instanceof O ? "ToolEventContent" : t instanceof pt ? "StreamingToolEventContent" : "Unknown";
+  }
+  static parseFromTypedEvent(t) {
+    var s, m, f, z, Et, Ft, Nt;
+    const i = b.parseFlatPropertiesTypedEvent(t);
+    if (i.serverError)
+      return i.parts.push(Dt.fromError(i.serverError)), i;
+    if (!t.content && !t.streamingParts)
+      return i;
+    i.parts = [];
+    const a = [...((s = t.content) == null ? void 0 : s.items) ?? [], ...t.streamingParts ?? []];
+    i.eventType = vt(((m = t.eventType) == null ? void 0 : m.type) ?? "");
+    for (const y of a) {
+      let c = {
+        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 = b.getPartType(y);
+      if (T == x.FunctionCallContent || T == x.FunctionResultContent || T == x.StreamingFinalFunctionCallContent || T == x.StreamingFinalFunctionResultContent) {
+        var o = y;
+        if (o.id == "Server Error")
+          c.eventType = l.ServerError, c.errorDetails = {
+            errorMessage: JSON.stringify(o.arguments)
+          }, c.functionDetails = void 0;
+        else {
+          c.eventType = T == x.FunctionCallContent || T == x.StreamingFinalFunctionCallContent ? l.FunctionCall : l.FunctionResponse;
+          let d;
+          try {
+            if (o != null && o.result)
+              if (typeof o.result == "object")
+                d = o.result;
+              else if (typeof o.result == "string") {
+                const gt = JSON.parse(o.result);
+                d = typeof gt == "object" && gt !== null ? gt : o.result;
+              } else
+                d = o.result;
+          } catch (gt) {
+            console.warn("Parse function error", gt), d = o == null ? void 0 : o.result;
+          }
+          c.thoughtDetails = {
+            text: ""
+          }, c.functionDetails = {
+            id: (o == null ? void 0 : o.id) ?? "",
+            args: o == null ? void 0 : o.arguments,
+            start: T == x.FunctionCallContent ? i.created : void 0,
+            end: T == x.FunctionResultContent ? i.created : void 0,
+            text: JSON.stringify(o == null ? void 0 : o.arguments) ?? "",
+            name: (o == null ? void 0 : o.functionName) ?? "",
+            status: c.eventType == l.FunctionCall ? "Executing" : "Done",
+            response: d,
+            isUi: (o == null ? void 0 : o.isUi) === !0 || typeof (o == null ? void 0 : o.arguments) == "object" && (o == null ? void 0 : o.arguments) !== null && o.arguments.__isUi === !0,
+            // Friendly args summary for the chip — mirrors __isUi: the live streaming part
+            // carries `friendlyArgsDescription`; the persisted FunctionCall carries
+            // `__argsDescription` in its args (see StreamingFinalFunctionCallContent.ToKernelContent).
+            argsDescription: (o == null ? void 0 : o.friendlyArgsDescription) ?? (typeof (o == null ? void 0 : o.arguments) == "object" && (o == null ? void 0 : o.arguments) !== null ? o.arguments.__argsDescription : void 0),
+            // Client-only payload riding the RESULT event. The streaming form carries it
+            // top-level (clientOutput); when the runtime collapses that to a sealed
+            // FunctionResultContent (ToKernelContent) the payload rides in metadata, and
+            // the client's part flattener keeps THAT collapsed part — so read both. Calls
+            // leave it undefined. The persisted-replay form folds in via FunctionClientOutputContent.
+            clientOutput: (o == null ? void 0 : o.clientOutput) ?? ((f = o == null ? void 0 : o.metadata) == null ? void 0 : f.clientOutput)
+          }, t.text = o == null ? void 0 : o.arguments;
+        }
+      } else if (T == x.StreamingTextContent)
+        c.eventType = l.Text, c.text = (z = y == null ? void 0 : y.text) == null ? void 0 : z.replaceAll("\\n", `
+`), c.textLastChunk = y.text, t.text = c.text;
+      else if (T == x.TextContent)
+        c.eventType = l.Text, c.text = (Et = y == null ? void 0 : y.text) == null ? void 0 : Et.replaceAll("\\n", `
+`), c.textLastChunk = y.text, t.text = c.text;
+      else if (T == x.StreamingReasoningContent)
+        c.eventType = l.Thought, c.thoughtDetails = {
+          text: ((Ft = y == null ? void 0 : y.text) == null ? void 0 : Ft.replaceAll("\\n", `
+`)) ?? ""
+        }, c.text = (Nt = y == null ? void 0 : y.text) == null ? void 0 : Nt.replaceAll("\\n", `
+`), c.textLastChunk = y.text, t.text = c.text;
+      else if (T == x.StreamingFunctionCallUpdateContent) {
+        const d = y;
+        c.eventType = l.PartialFunctionCall, c.text = d.arguments, c.thoughtDetails = {
+          text: ""
+        }, c.functionDetails = {
+          id: d.callId ?? "",
+          text: c.text,
+          status: "Composing",
+          name: (d == null ? void 0 : d.name) ?? "Unknown"
+        }, t.text = c.text;
+      } else if (T == x.ToolEventContent || T == x.StreamingToolEventContent) {
+        c.eventType = l.ToolEvent;
+        const d = y;
+        c.toolDetails = {
+          eventName: d.eventName ?? "",
+          eventData: d.eventData ?? "",
+          sessionId: d.sessionId ?? void 0
+        };
+      } else if (T == x.FunctionClientOutputContent) {
+        const d = y;
+        c.eventType = l.FunctionClientOutput, c.functionDetails = {
+          id: d.id ?? "",
+          name: "",
+          status: "Done",
+          clientOutput: d.data
+        };
+      } else if (T == x.UserUiContent) {
+        const d = y;
+        c.eventType = l.UserAnswer, c.author = "user", c.functionDetails = {
+          id: "",
+          name: d.name ?? "",
+          args: d.args,
+          status: "Done",
+          isUi: !0
+        };
+      } else {
+        c.eventType = l.NotDefined, console.warn(`Got a unmapped event_type:${i.eventType}, data:`, T, y);
+        continue;
+      }
+      i.parts.push(c);
+    }
+    return i;
+  }
+  static createFromThought(t, i) {
+    return {
+      author: "main",
+      visible: !0,
+      eventType: l.Thought,
+      uniqueId: (/* @__PURE__ */ new Date()).getTime().toString(),
+      interactionId: t,
+      allEventTypes: [l.Thought],
+      artifactsDelta: [""],
+      model_session_id: "",
+      created: /* @__PURE__ */ new Date(),
+      turn_complete: !1,
+      partial: !0,
+      asyncFinalResponse: !1,
+      mimeType: "text/plain",
+      parts: [
+        {
+          thoughtDetails: {
+            text: i
+          },
+          id: xt(),
+          created: /* @__PURE__ */ new Date(),
+          eventType: l.Thought,
+          author: "main",
+          isStillWriting: !1,
+          textAppendable: !0,
+          partial: !0,
+          mustPush: !0
+        }
+      ]
+    };
+  }
+  static createFromFunctionName(t, i, a) {
+    const o = b.createFromText("", i);
+    return o.parts[0].text = void 0, o.parts[0].thoughtDetails = void 0, o.parts[0].textAppendable = !1, o.parts[0].mustPush = !0, o.parts[0].functionDetails = {
+      name: t,
+      id: "callId",
+      status: "Executing",
+      start: /* @__PURE__ */ new Date(),
+      end: void 0,
+      text: "dfsdfdf",
+      args: a
+    }, o;
+  }
+  static createFromText(t, i, a) {
+    return {
+      author: "main",
+      visible: !0,
+      eventType: l.Text,
+      uniqueId: (/* @__PURE__ */ new Date()).getTime().toString(),
+      interactionId: i,
+      allEventTypes: [l.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: a ? {
+            text: a
+          } : void 0,
+          id: xt(),
+          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: l.Text,
+          author: "main",
+          isStillWriting: !1,
+          textAppendable: !0,
+          partial: !0,
+          mustPush: !0,
+          text: t
+        }
+      ]
+    };
+  }
+};
+u(b, "ServerEvent");
+let bt = b;
+const Rt = [
+  // KernelContent derived types
+  dt,
+  ft,
+  A,
+  O,
+  R,
+  ut,
+  lt,
+  ct,
+  // StreamingKernelContent derived types
+  St,
+  w,
+  Tt,
+  I,
+  N,
+  _
+];
+function Jt(p) {
+  return p.name;
+}
+u(Jt, "getConstructorName");
+function wt(p, t, i, a) {
+  t.constructor !== i && (p.$type = (a == null ? void 0 : a.name) ?? Jt(t.constructor));
+}
+u(wt, "dotNetTypeEmitter");
+function Pt(p, t) {
+  if (p.$type != null)
+    return t.get(p.$type);
+}
+u(Pt, "dotnetTypeResolver");
+function Ut() {
+  const p = new At(S);
+  return p.config({
+    knownTypes: Rt,
+    typeHintEmitter: wt,
+    typeResolver: Pt
+  }), p;
+}
+u(Ut, "createEventSerializer");
+function Wt() {
+  const p = new At(F);
+  return p.config({
+    knownTypes: Rt,
+    typeHintEmitter: wt,
+    typeResolver: Pt
+  }), p;
+}
+u(Wt, "createStreamingResponseSerializer");
+function Ot(p) {
+  try {
+    return JSON.parse(p), p;
+  } catch {
+    let i = "", a = !1;
+    for (let o = 0; o < p.length; o++) {
+      const s = p[o], m = s.charCodeAt(0);
+      if (s === "\\" && a && o + 1 < p.length) {
+        const f = p[o + 1];
+        if (f === '"' || f === "\\" || f === "/" || f === "b" || f === "f" || f === "n" || f === "r" || f === "t") {
+          i += s + f, o++;
+          continue;
+        } else if (f === "u" && o + 5 < p.length) {
+          i += p.substring(o, o + 6), o += 5;
+          continue;
+        } else {
+          i += s;
+          continue;
+        }
+      }
+      if (s === '"') {
+        let f = 0;
+        for (let z = o - 1; z >= 0 && p[z] === "\\"; z--)
+          f++;
+        f % 2 === 0 && (a = !a), i += s;
+        continue;
+      }
+      if (a && m < 32)
+        switch (s) {
+          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 f = m.toString(16).padStart(4, "0");
+            i += `\\u${f}`;
+            break;
+        }
+      else
+        i += s;
+    }
+    return i;
+  }
+}
+u(Ot, "sanitizeJsonString");
+function Bt(p) {
+  const t = Ot(p);
+  return Wt().parse(t);
+}
+u(Bt, "deserializePayload");
+function Mt(p) {
+  const t = Ot(p);
+  return Ut().parse(t);
+}
+u(Mt, "deserializeEvent");
+function Kt(p) {
+  return Ut().stringify(p);
+}
+u(Kt, "serializeEvent");
+export {
+  ct as C,
+  A as F,
+  Dt as I,
+  S as L,
+  x as P,
+  bt as S,
+  dt as T,
+  R as a,
+  w as b,
+  Tt as c,
+  F as d,
+  St as e,
+  Ut as f,
+  Wt as g,
+  Mt as h,
+  Bt as i,
+  Kt as j,
+  Ot as s
+};
+//# sourceMappingURL=serializer-DyHZxlAG.js.map