@amodalai/chat-widget 0.1.0

package/dist/index-m6lGOMRo.js

@@ -0,0 +1,641 @@
+var E = Object.defineProperty;
+var I = (r, e, t) => e in r ? E(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var c = (r, e, t) => I(r, typeof e != "symbol" ? e + "" : e, t);
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+function w(r) {
+  if (!r.startsWith("data: ")) return null;
+  const e = r.slice(6).trim();
+  return e.length === 0 ? null : JSON.parse(e);
+}
+async function* u(r, e, t, s) {
+  const o = `${r}/chat/stream`, n = {
+    "Content-Type": "application/json"
+  };
+  s && (n.Authorization = `Bearer ${s}`);
+  const l = await fetch(o, {
+    method: "POST",
+    headers: n,
+    body: JSON.stringify(e),
+    signal: t
+  });
+  if (!l.ok)
+    throw new Error(`Chat request failed: ${String(l.status)} ${l.statusText}`);
+  const i = l.body;
+  if (!i)
+    throw new Error("Response body is null");
+  const a = i.getReader(), d = new TextDecoder();
+  let m = "";
+  try {
+    for (; ; ) {
+      const { done: h, value: x } = await a.read();
+      if (h) break;
+      m += d.decode(x, { stream: !0 });
+      const y = m.split(`
+`);
+      m = y.pop() ?? "";
+      for (const C of y) {
+        const _ = C.trim();
+        if (_.length === 0) continue;
+        const g = w(_);
+        g && (yield g);
+      }
+    }
+    if (m.trim().length > 0) {
+      const h = w(m.trim());
+      h && (yield h);
+    }
+  } finally {
+    a.releaseLock();
+  }
+}
+async function b(r, e, t) {
+  const s = `${r}/sessions`, o = {
+    "Content-Type": "application/json"
+  };
+  t && (o.Authorization = `Bearer ${t}`);
+  const n = { user_id: e.id };
+  e.role && (n.role = e.role);
+  const l = await fetch(s, {
+    method: "POST",
+    headers: o,
+    body: JSON.stringify(n)
+  });
+  if (!l.ok)
+    throw new Error(`Session creation failed: ${String(l.status)} ${l.statusText}`);
+  return await l.json();
+}
+function f(r) {
+  const e = {};
+  return r && (e.Authorization = `Bearer ${r}`), e;
+}
+async function A(r, e, t) {
+  const s = t && t.length > 0 ? `?tags=${t.join(",")}` : "", o = `${r}/sessions/history${s}`, n = await fetch(o, { headers: f(e) });
+  if (!n.ok)
+    throw new Error(`List sessions failed: ${String(n.status)} ${n.statusText}`);
+  return await n.json();
+}
+async function T(r, e, t) {
+  const s = `${r}/sessions/history/${e}`, o = await fetch(s, { headers: f(t) });
+  if (!o.ok)
+    throw new Error(`Get session failed: ${String(o.status)} ${o.statusText}`);
+  return await o.json();
+}
+async function $(r, e, t, s) {
+  const o = `${r}/sessions/history/${e}`, n = await fetch(o, {
+    method: "PATCH",
+    headers: {
+      "Content-Type": "application/json",
+      ...f(s)
+    },
+    body: JSON.stringify(t)
+  });
+  if (!n.ok)
+    throw new Error(`Update session failed: ${String(n.status)} ${n.statusText}`);
+  return await n.json();
+}
+function j(r, e) {
+  return {
+    stream: (t, s) => u(r, t, s, e),
+    createSession: (t) => b(r, t, e),
+    listSessions: (t) => A(r, e, t),
+    getSessionHistory: (t) => T(r, t, e),
+    updateSession: (t, s) => $(r, t, s, e)
+  };
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+class S {
+  constructor() {
+    c(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(e, t) {
+    let s = this.listeners.get(e);
+    return s || (s = /* @__PURE__ */ new Set(), this.listeners.set(e, s)), s.add(t), this;
+  }
+  off(e, t) {
+    const s = this.listeners.get(e);
+    return s && (s.delete(t), s.size === 0 && this.listeners.delete(e)), this;
+  }
+  emit(e, t) {
+    const s = this.listeners.get(e);
+    if (s)
+      for (const o of s)
+        o(t);
+  }
+  removeAllListeners() {
+    return this.listeners.clear(), this;
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+function v(r) {
+  const e = [];
+  return r.type === "widget_rendered" && B(r.widgetType, r.data, e), r.type === "tool_executed" && z(r.parameters, e), e;
+}
+function B(r, e, t) {
+  switch (r) {
+    case "entity-card": {
+      typeof e.mac == "string" && t.push({
+        entityType: "device",
+        entityId: e.mac,
+        source: "widget:entity-card"
+      }), typeof e.zone == "string" && t.push({
+        entityType: "zone",
+        entityId: e.zone,
+        source: "widget:entity-card"
+      });
+      break;
+    }
+    case "entity-list": {
+      const s = e.devices;
+      if (Array.isArray(s))
+        for (const o of s)
+          typeof o == "object" && o !== null && "mac" in o && typeof o.mac == "string" && t.push({
+            entityType: "device",
+            entityId: o.mac,
+            source: "widget:entity-list"
+          });
+      break;
+    }
+    case "scope-map": {
+      const s = e.highlight_zones;
+      if (Array.isArray(s))
+        for (const n of s)
+          typeof n == "string" && t.push({
+            entityType: "zone",
+            entityId: n,
+            source: "widget:scope-map"
+          });
+      const o = e.highlight_devices;
+      if (Array.isArray(o))
+        for (const n of o)
+          typeof n == "string" && t.push({
+            entityType: "device",
+            entityId: n,
+            source: "widget:scope-map"
+          });
+      break;
+    }
+    case "alert-card": {
+      const s = e.alert_id ?? e.id;
+      typeof s == "string" && t.push({
+        entityType: "alert",
+        entityId: s,
+        source: "widget:alert-card"
+      });
+      break;
+    }
+  }
+}
+function z(r, e) {
+  typeof r.zone == "string" && e.push({
+    entityType: "zone",
+    entityId: r.zone,
+    source: "tool:parameter"
+  }), typeof r.mac == "string" && e.push({
+    entityType: "device",
+    entityId: r.mac,
+    source: "tool:parameter"
+  });
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+class P extends S {
+  constructor() {
+    super(...arguments);
+    c(this, "extractors", [v]);
+  }
+  /**
+   * Process an agent-driven event: emit on its typed channel + '*',
+   * then run entity extractors and emit entity_referenced for each found entity.
+   */
+  processEvent(t) {
+    if (this.emit(t.type, t), this.emit("*", t), t.type === "tool_executed" || t.type === "skill_activated" || t.type === "widget_rendered" || t.type === "kb_proposal")
+      for (const s of this.extractors) {
+        const o = s(t);
+        for (const n of o) {
+          const l = {
+            type: "entity_referenced",
+            entity: n,
+            sourceEvent: t,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.emit("entity_referenced", l), this.emit("*", l);
+        }
+      }
+  }
+  /**
+   * Emit an interaction event (entity_hovered, entity_unhovered, entity_clicked).
+   * These are emitted on their typed channel + '*' without running extractors,
+   * since interaction events already carry their EntityReference.
+   */
+  emitInteraction(t) {
+    this.emit(t.type, t), this.emit("*", t);
+  }
+  /** Add a custom entity extractor. */
+  addExtractor(t) {
+    this.extractors.push(t);
+  }
+  /** Replace all entity extractors (including the default). */
+  setExtractors(t) {
+    this.extractors = [...t];
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+class N {
+  constructor(e, t, s) {
+    c(this, "handlers", {
+      text: [],
+      tool_call: [],
+      tool_result: [],
+      skill_activated: [],
+      kb_proposal: [],
+      widget: [],
+      ask_user: [],
+      error: [],
+      done: []
+    });
+    c(this, "abortController");
+    c(this, "started", !1);
+    c(this, "response", {
+      text: "",
+      toolCalls: [],
+      skillsUsed: [],
+      kbProposals: []
+    });
+    c(this, "toolCallNames", /* @__PURE__ */ new Map());
+    c(this, "token");
+    this.serverUrl = e, this.request = t, this.abortController = new AbortController(), this.token = s, queueMicrotask(() => this.start());
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- overload implementation requires broad type
+  on(e, t) {
+    const s = e;
+    return s in this.handlers && this.handlers[s].push(t), this;
+  }
+  /** Cancel the stream. */
+  abort() {
+    this.abortController.abort();
+  }
+  async start() {
+    if (!this.started) {
+      this.started = !0;
+      try {
+        const e = u(
+          this.serverUrl,
+          this.request,
+          this.abortController.signal,
+          this.token
+        );
+        for await (const t of e)
+          this.processEvent(t);
+        for (const t of this.handlers.done)
+          t(this.response);
+      } catch (e) {
+        if (!(e instanceof DOMException && e.name === "AbortError")) {
+          const t = e instanceof Error ? e.message : "Unknown error";
+          for (const s of this.handlers.error)
+            s({ message: t });
+        }
+      }
+    }
+  }
+  processEvent(e) {
+    switch (e.type) {
+      case "text_delta":
+        this.response.text += e.content;
+        for (const t of this.handlers.text)
+          t({ text: e.content });
+        break;
+      case "tool_call_start":
+        this.toolCallNames.set(e.tool_id, e.tool_name);
+        for (const t of this.handlers.tool_call)
+          t({ tool: e.tool_name, params: e.parameters, toolId: e.tool_id });
+        this.response.toolCalls.push({
+          toolId: e.tool_id,
+          toolName: e.tool_name,
+          parameters: e.parameters,
+          status: "running"
+        });
+        break;
+      case "tool_call_result": {
+        const t = this.toolCallNames.get(e.tool_id) ?? "";
+        for (const o of this.handlers.tool_result)
+          o({ tool: t, data: e.result, duration_ms: e.duration_ms, toolId: e.tool_id });
+        const s = this.response.toolCalls.find((o) => o.toolId === e.tool_id);
+        s && (s.status = e.status, s.result = e.result, s.duration_ms = e.duration_ms, s.error = e.error);
+        break;
+      }
+      case "skill_activated":
+        this.response.skillsUsed.push(e.skill);
+        for (const t of this.handlers.skill_activated)
+          t({ name: e.skill });
+        break;
+      case "kb_proposal": {
+        const t = {
+          scope: e.scope,
+          title: e.title,
+          reasoning: e.reasoning
+        };
+        this.response.kbProposals.push(t);
+        for (const s of this.handlers.kb_proposal)
+          s(t);
+        break;
+      }
+      case "ask_user":
+        for (const t of this.handlers.ask_user)
+          t({ askId: e.ask_id, questions: e.questions });
+        break;
+      case "error":
+        for (const t of this.handlers.error)
+          t({ message: e.message });
+        break;
+      case "init":
+      case "done":
+        break;
+      default: {
+        const t = e;
+        if (t.type === "widget" && t.widget_type && t.data)
+          for (const s of this.handlers.widget)
+            s({ widgetType: t.widget_type, data: t.data });
+        break;
+      }
+    }
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+let k = 0;
+function p() {
+  return k++, `msg-${Date.now()}-${String(k)}`;
+}
+class D extends S {
+  constructor(t) {
+    super();
+    c(this, "config");
+    c(this, "sessionId", null);
+    c(this, "_messages", []);
+    c(this, "_isConnected", !1);
+    c(this, "_isStreaming", !1);
+    c(this, "connectAttempt", 0);
+    c(this, "maxReconnectAttempts", 3);
+    c(this, "_eventBus");
+    this.config = t, this._eventBus = new P(), t.entityExtractors && this._eventBus.setExtractors(t.entityExtractors), this._eventBus.on("entity_referenced", (s) => {
+      this.emit("entity_referenced", s);
+    });
+  }
+  /** The widget event bus. Subscribe to agent-driven events here. */
+  get events() {
+    return this._eventBus;
+  }
+  /** Whether the client has an active session. */
+  get isConnected() {
+    return this._isConnected;
+  }
+  /** Whether a response is currently streaming. */
+  get isStreaming() {
+    return this._isStreaming;
+  }
+  /** Current session ID, or null if not connected. */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /** Readonly message history. */
+  get messages() {
+    return this._messages;
+  }
+  /** Establish a session with the server. */
+  async connect() {
+    try {
+      const t = await b(
+        this.config.serverUrl,
+        this.config.user,
+        this.config.token
+      );
+      this.sessionId = t.session_id, this._isConnected = !0, this.connectAttempt = 0, this.emit("connected", void 0);
+    } catch (t) {
+      const s = t instanceof Error ? t : new Error(String(t));
+      throw this.emit("error", s), s;
+    }
+  }
+  /** Disconnect and clean up. */
+  async disconnect() {
+    this.sessionId = null, this._isConnected = !1, this._isStreaming = !1, this.emit("disconnected", void 0);
+  }
+  /** Clear message history. */
+  clearHistory() {
+    this._messages = [];
+  }
+  /**
+   * Send a message and wait for the full response.
+   * Auto-connects if not already connected.
+   */
+  async send(t) {
+    this._isConnected || await this.connect();
+    const s = {
+      type: "user",
+      id: p(),
+      text: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(s), this.emit("message", s);
+    const o = {
+      type: "assistant_text",
+      id: p(),
+      text: "",
+      toolCalls: [],
+      skillActivations: [],
+      kbProposals: [],
+      widgets: [],
+      contentBlocks: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(o), this.emit("message", o), this._isStreaming = !0, this.emit("streaming_start", void 0);
+    try {
+      return await this.streamInternal(t, o);
+    } catch (n) {
+      if (this.connectAttempt < this.maxReconnectAttempts)
+        return await this.reconnectAndRetry(t, o);
+      throw n;
+    } finally {
+      this._isStreaming = !1, this.emit("streaming_end", void 0);
+    }
+  }
+  /**
+   * Stream a message, returning a ChatStream handle for event-based consumption.
+   */
+  stream(t) {
+    const s = {
+      type: "user",
+      id: p(),
+      text: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(s), this.emit("message", s), this._isStreaming = !0, this.emit("streaming_start", void 0);
+    const o = new N(this.config.serverUrl, {
+      message: t,
+      session_id: this.sessionId ?? void 0,
+      role: this.config.user.role
+    }, this.config.token);
+    return o.on("done", (n) => {
+      const l = {
+        type: "assistant_text",
+        id: p(),
+        text: n.text,
+        toolCalls: n.toolCalls,
+        skillActivations: n.skillsUsed,
+        kbProposals: n.kbProposals,
+        widgets: [],
+        contentBlocks: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this._messages.push(l), this.emit("message", l), this._isStreaming = !1, this.emit("streaming_end", void 0);
+    }), o.on("error", (n) => {
+      this._isStreaming = !1, this.emit("streaming_end", void 0), this.emit("error", new Error(n.message));
+    }), o;
+  }
+  async streamInternal(t, s) {
+    const o = {
+      text: "",
+      toolCalls: [],
+      skillsUsed: [],
+      kbProposals: []
+    }, n = /* @__PURE__ */ new Map(), l = u(
+      this.config.serverUrl,
+      {
+        message: t,
+        session_id: this.sessionId ?? void 0,
+        role: this.config.user.role
+      },
+      void 0,
+      this.config.token
+    );
+    for await (const i of l)
+      switch (i.type) {
+        case "init":
+          this.sessionId = i.session_id;
+          break;
+        case "text_delta":
+          o.text += i.content, s.text += i.content;
+          break;
+        case "tool_call_start": {
+          const a = {
+            toolId: i.tool_id,
+            toolName: i.tool_name,
+            parameters: i.parameters,
+            status: "running"
+          };
+          o.toolCalls.push(a), s.toolCalls = [...s.toolCalls, a], n.set(i.tool_id, {
+            toolName: i.tool_name,
+            parameters: i.parameters
+          });
+          break;
+        }
+        case "tool_call_result": {
+          const a = o.toolCalls.find((h) => h.toolId === i.tool_id);
+          a && (a.status = i.status, a.result = i.result, a.duration_ms = i.duration_ms, a.error = i.error), s.toolCalls = s.toolCalls.map(
+            (h) => h.toolId === i.tool_id ? { ...h, status: i.status, result: i.result, duration_ms: i.duration_ms, error: i.error } : h
+          );
+          const d = n.get(i.tool_id);
+          n.delete(i.tool_id);
+          const m = {
+            type: "tool_executed",
+            toolName: (d == null ? void 0 : d.toolName) ?? "",
+            toolId: i.tool_id,
+            parameters: (d == null ? void 0 : d.parameters) ?? {},
+            status: i.status,
+            result: i.result,
+            duration_ms: i.duration_ms,
+            error: i.error,
+            timestamp: i.timestamp
+          };
+          this._eventBus.processEvent(m), this.emit("tool_executed", m);
+          break;
+        }
+        case "skill_activated": {
+          o.skillsUsed.push(i.skill), s.skillActivations = [...s.skillActivations, i.skill];
+          const a = {
+            type: "skill_activated",
+            skill: i.skill,
+            timestamp: i.timestamp
+          };
+          this._eventBus.processEvent(a), this.emit("skill_activated", a);
+          break;
+        }
+        case "kb_proposal": {
+          const a = {
+            scope: i.scope,
+            title: i.title,
+            reasoning: i.reasoning
+          };
+          o.kbProposals.push(a), s.kbProposals = [...s.kbProposals, a];
+          const d = {
+            type: "kb_proposal",
+            proposal: a,
+            timestamp: i.timestamp
+          };
+          this._eventBus.processEvent(d), this.emit("kb_proposal_received", d);
+          break;
+        }
+        case "widget": {
+          const a = {
+            type: "widget_rendered",
+            widgetType: i.widget_type,
+            data: i.data,
+            timestamp: i.timestamp
+          };
+          this._eventBus.processEvent(a), this.emit("widget_rendered", a);
+          break;
+        }
+        case "error":
+          throw new Error(i.message);
+      }
+    return o;
+  }
+  async reconnectAndRetry(t, s) {
+    this.connectAttempt++, this.emit("reconnecting", this.connectAttempt);
+    const o = 100 * Math.pow(2, this.connectAttempt - 1);
+    await new Promise((n) => setTimeout(n, o));
+    try {
+      return await this.connect(), await this.streamInternal(t, s);
+    } catch (n) {
+      if (this.connectAttempt < this.maxReconnectAttempts)
+        return this.reconnectAndRetry(t, s);
+      throw n;
+    }
+  }
+}
+export {
+  D as C,
+  S as T,
+  P as W,
+  N as a,
+  b,
+  j as c,
+  v as d,
+  T as g,
+  A as l,
+  w as p,
+  u as s,
+  $ as u
+};
+//# sourceMappingURL=index-m6lGOMRo.js.map