@aikaara/chat-sdk 0.1.0

package/dist/headless-DzI-CcOZ.mjs

@@ -0,0 +1,557 @@
+var b = Object.defineProperty;
+var v = (a, t, e) => t in a ? b(a, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[t] = e;
+var o = (a, t, e) => v(a, typeof t != "symbol" ? t + "" : t, e);
+class S {
+  constructor(t, e) {
+    o(this, "identifier");
+    o(this, "callbacks", {});
+    o(this, "sendFn");
+    this.identifier = t, this.sendFn = e;
+  }
+  onReceived(t) {
+    return this.callbacks.received = t, this;
+  }
+  onConnected(t) {
+    return this.callbacks.connected = t, this;
+  }
+  onDisconnected(t) {
+    return this.callbacks.disconnected = t, this;
+  }
+  onRejected(t) {
+    return this.callbacks.rejected = t, this;
+  }
+  perform(t, e = {}) {
+    this.sendFn({ action: t, ...e });
+  }
+  /** @internal */
+  _notifyReceived(t) {
+    var e, s;
+    (s = (e = this.callbacks).received) == null || s.call(e, t);
+  }
+  /** @internal */
+  _notifyConnected() {
+    var t, e;
+    (e = (t = this.callbacks).connected) == null || e.call(t);
+  }
+  /** @internal */
+  _notifyDisconnected() {
+    var t, e;
+    (e = (t = this.callbacks).disconnected) == null || e.call(t);
+  }
+  /** @internal */
+  _notifyRejected() {
+    var t, e;
+    (e = (t = this.callbacks).rejected) == null || e.call(t);
+  }
+}
+class f {
+  constructor(t) {
+    o(this, "ws", null);
+    o(this, "url");
+    o(this, "subscriptions", /* @__PURE__ */ new Map());
+    o(this, "welcomePromise", null);
+    o(this, "pendingSubscriptions", /* @__PURE__ */ new Map());
+    this.url = t;
+  }
+  connect() {
+    return new Promise((t, e) => {
+      this.welcomePromise = { resolve: t, reject: e }, this.ws = new WebSocket(this.url), this.ws.onopen = () => {
+      }, this.ws.onmessage = (s) => {
+        this.handleMessage(s);
+      }, this.ws.onerror = () => {
+        var n;
+        const s = new Error("WebSocket connection error");
+        (n = this.welcomePromise) == null || n.reject(s), this.welcomePromise = null;
+      }, this.ws.onclose = () => {
+        this.subscriptions.forEach((s) => s._notifyDisconnected());
+      };
+    });
+  }
+  disconnect() {
+    this.ws && (this.ws.onclose = null, this.ws.close(), this.ws = null), this.subscriptions.forEach((t) => t._notifyDisconnected()), this.subscriptions.clear();
+  }
+  subscribe(t) {
+    const e = JSON.stringify(t), s = new S(e, (n) => {
+      this.send({
+        command: "message",
+        identifier: e,
+        data: JSON.stringify(n)
+      });
+    });
+    return this.subscriptions.set(e, s), this.send({
+      command: "subscribe",
+      identifier: e
+    }), s;
+  }
+  subscribeAsync(t) {
+    const e = this.subscribe(t), s = e.identifier;
+    return new Promise((n, i) => {
+      this.pendingSubscriptions.set(s, {
+        resolve: () => n(e),
+        reject: i
+      }), setTimeout(() => {
+        this.pendingSubscriptions.has(s) && (this.pendingSubscriptions.delete(s), i(new Error(`Subscription timeout for ${s}`)));
+      }, 1e4);
+    });
+  }
+  unsubscribe(t) {
+    this.send({
+      command: "unsubscribe",
+      identifier: t
+    }), this.subscriptions.delete(t);
+  }
+  perform(t, e, s = {}) {
+    this.send({
+      command: "message",
+      identifier: t,
+      data: JSON.stringify({ action: e, ...s })
+    });
+  }
+  get isConnected() {
+    var t;
+    return ((t = this.ws) == null ? void 0 : t.readyState) === WebSocket.OPEN;
+  }
+  send(t) {
+    var e;
+    ((e = this.ws) == null ? void 0 : e.readyState) === WebSocket.OPEN && this.ws.send(JSON.stringify(t));
+  }
+  handleMessage(t) {
+    var s;
+    let e;
+    try {
+      e = JSON.parse(t.data);
+    } catch {
+      return;
+    }
+    switch (e.type) {
+      case "welcome":
+        (s = this.welcomePromise) == null || s.resolve(), this.welcomePromise = null;
+        break;
+      case "ping":
+        break;
+      case "confirm_subscription": {
+        const n = e.identifier, i = this.subscriptions.get(n);
+        i == null || i._notifyConnected();
+        const c = this.pendingSubscriptions.get(n);
+        c && (c.resolve(), this.pendingSubscriptions.delete(n));
+        break;
+      }
+      case "reject_subscription": {
+        const n = e.identifier, i = this.subscriptions.get(n);
+        i == null || i._notifyRejected(), this.subscriptions.delete(n);
+        const c = this.pendingSubscriptions.get(n);
+        c && (c.reject(new Error(`Subscription rejected: ${n}`)), this.pendingSubscriptions.delete(n));
+        break;
+      }
+      case "disconnect":
+        this.subscriptions.forEach((n) => n._notifyDisconnected());
+        break;
+      default: {
+        if (e.identifier && e.message !== void 0) {
+          const n = this.subscriptions.get(e.identifier);
+          n == null || n._notifyReceived(e.message);
+        }
+        break;
+      }
+    }
+  }
+}
+class _ {
+  constructor() {
+    o(this, "handlers", /* @__PURE__ */ new Map());
+  }
+  on(t, e) {
+    return this.handlers.has(t) || this.handlers.set(t, /* @__PURE__ */ new Set()), this.handlers.get(t).add(e), () => this.off(t, e);
+  }
+  off(t, e) {
+    var s;
+    (s = this.handlers.get(t)) == null || s.delete(e);
+  }
+  emit(t, e) {
+    var s;
+    (s = this.handlers.get(t)) == null || s.forEach((n) => {
+      try {
+        n(e);
+      } catch (i) {
+        console.error(`Error in event handler for "${t}":`, i);
+      }
+    });
+  }
+  removeAllListeners() {
+    this.handlers.clear();
+  }
+}
+const y = 1e3, w = 10, A = 400, C = 600, O = "#6366f1", U = 12, D = "system-ui, -apple-system, sans-serif", R = "Type a message...", N = "bottom-right", F = "light", L = { x: 20, y: 20 }, m = "aikaara_conversation_id";
+class k extends _ {
+  constructor(e) {
+    super();
+    o(this, "client");
+    o(this, "config");
+    o(this, "state", "disconnected");
+    o(this, "reconnectAttempt", 0);
+    o(this, "reconnectTimer", null);
+    this.config = e;
+    const s = this.buildWsUrl(e.baseUrl, e.userToken);
+    this.client = new f(s);
+  }
+  async connect() {
+    this.setState("connecting");
+    try {
+      await this.client.connect(), this.setState("connected"), this.reconnectAttempt = 0;
+    } catch (e) {
+      if (this.setState("disconnected"), this.config.reconnect !== !1)
+        this.scheduleReconnect();
+      else
+        throw e;
+    }
+  }
+  async disconnect() {
+    this.clearReconnectTimer(), this.client.disconnect(), this.setState("disconnected");
+  }
+  subscribeToConversation(e) {
+    return this.client.subscribeAsync({
+      channel: "ConversationChannel",
+      conversation_id: e
+    });
+  }
+  sendMessage(e, s) {
+    const n = JSON.stringify({
+      channel: "ConversationChannel",
+      conversation_id: e
+    });
+    this.client.perform(n, "send_message", { content: s });
+  }
+  sendUserEvent(e, s, n, i) {
+    const c = JSON.stringify({
+      channel: "ConversationChannel",
+      conversation_id: e
+    });
+    this.client.perform(c, "send_user_event", {
+      event_key: s,
+      ...n && { value: n },
+      ...i && { source: i }
+    });
+  }
+  get connectionState() {
+    return this.state;
+  }
+  setState(e) {
+    this.state !== e && (this.state = e, this.emit("connection:state", e));
+  }
+  scheduleReconnect() {
+    const e = this.config.maxReconnectAttempts ?? w;
+    if (this.reconnectAttempt >= e) {
+      this.emit("error", new Error("Max reconnection attempts reached"));
+      return;
+    }
+    this.setState("reconnecting");
+    const n = (this.config.reconnectInterval ?? y) * Math.pow(2, this.reconnectAttempt);
+    this.reconnectAttempt++, this.reconnectTimer = setTimeout(async () => {
+      try {
+        const i = this.buildWsUrl(this.config.baseUrl, this.config.userToken);
+        this.client = new f(i), await this.connect();
+      } catch {
+      }
+    }, n);
+  }
+  clearReconnectTimer() {
+    this.reconnectTimer && (clearTimeout(this.reconnectTimer), this.reconnectTimer = null);
+  }
+  buildWsUrl(e, s) {
+    return `${e.replace(/^http/, "ws")}/cable?token=${s}`;
+  }
+}
+class I {
+  constructor(t, e, s) {
+    o(this, "baseUrl");
+    o(this, "apiKey");
+    o(this, "userToken");
+    this.baseUrl = t, this.userToken = e, this.apiKey = s;
+  }
+  async createConversation(t) {
+    const e = {
+      conversation: {
+        ...t.systemPromptId && { system_prompt_id: t.systemPromptId },
+        ...t.channel && { channel: t.channel },
+        ...t.title && { title: t.title }
+      }
+    };
+    return this.request("POST", "/api/v1/conversations", e);
+  }
+  async getMessages(t) {
+    return (await this.request(
+      "GET",
+      `/api/v1/conversations/${t}/messages`
+    )).map(this.mapMessage);
+  }
+  mapMessage(t) {
+    var e;
+    return {
+      id: String(t.id),
+      conversationId: String(t.conversation_id),
+      role: t.role,
+      content: t.content || "",
+      toolCalls: (e = t.tool_calls) == null ? void 0 : e.map((s) => ({
+        id: s.id,
+        type: s.type,
+        function: s.function
+      })),
+      toolCallResults: t.tool_call_results,
+      tokensInput: t.tokens_input,
+      tokensOutput: t.tokens_output,
+      metadata: t.metadata,
+      createdAt: t.created_at,
+      status: "complete"
+    };
+  }
+  async request(t, e, s) {
+    const n = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    this.apiKey && (n["X-Api-Key"] = this.apiKey);
+    const i = `${this.baseUrl}${e}`, c = { method: t, headers: n };
+    s && (c.body = JSON.stringify(s));
+    const d = await fetch(i, c);
+    if (!d.ok) {
+      const l = await d.text();
+      let u;
+      try {
+        const g = JSON.parse(l);
+        u = g.error || g.message || l;
+      } catch {
+        u = l;
+      }
+      throw new Error(`API error ${d.status}: ${u}`);
+    }
+    return d.json();
+  }
+}
+class E {
+  constructor() {
+    o(this, "_messages", []);
+    o(this, "optimisticCounter", 0);
+  }
+  get messages() {
+    return [...this._messages];
+  }
+  addOptimistic(t, e, s) {
+    const n = {
+      id: `optimistic_${++this.optimisticCounter}`,
+      conversationId: s,
+      role: t,
+      content: e,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "sending"
+    };
+    return this._messages.push(n), n;
+  }
+  confirmOptimistic(t) {
+    const e = this._messages.find((s) => s.id === t);
+    e && (e.status = "sent");
+  }
+  addStreamingMessage(t) {
+    const e = {
+      id: `streaming_${Date.now()}`,
+      conversationId: t,
+      role: "assistant",
+      content: "",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "streaming"
+    };
+    return this._messages.push(e), e;
+  }
+  updateStreaming(t) {
+    const e = this._messages.findLast((s) => s.status === "streaming");
+    e && (e.content = t);
+  }
+  finalizeStreaming(t) {
+    const e = this._messages.findLast((s) => s.status === "streaming");
+    return e && (e.status = "complete", t && (e.tokensInput = t.tokensInput, e.tokensOutput = t.tokensOutput)), e;
+  }
+  addMessage(t) {
+    this._messages.push(t);
+  }
+  setMessages(t) {
+    this._messages = [...t];
+  }
+  clear() {
+    this._messages = [];
+  }
+}
+class T {
+  constructor(t, e = !0) {
+    o(this, "_conversationId");
+    o(this, "persist");
+    this.persist = e, this._conversationId = t || this.loadFromStorage();
+  }
+  get conversationId() {
+    return this._conversationId;
+  }
+  set conversationId(t) {
+    this._conversationId = t, this.persist && t && this.saveToStorage(t);
+  }
+  clear() {
+    if (this._conversationId = null, this.persist)
+      try {
+        localStorage.removeItem(m);
+      } catch {
+      }
+  }
+  loadFromStorage() {
+    if (!this.persist) return null;
+    try {
+      return localStorage.getItem(m);
+    } catch {
+      return null;
+    }
+  }
+  saveToStorage(t) {
+    try {
+      localStorage.setItem(m, t);
+    } catch {
+    }
+  }
+}
+class P extends _ {
+  constructor(e) {
+    super();
+    o(this, "connection");
+    o(this, "api");
+    o(this, "messageStore");
+    o(this, "conversationManager");
+    o(this, "subscription", null);
+    o(this, "config");
+    this.config = e, this.connection = new k(e), this.api = new I(e.baseUrl, e.userToken, e.apiKey), this.messageStore = new E(), this.conversationManager = new T(e.conversationId), this.connection.on("connection:state", (s) => {
+      var n, i;
+      this.emit("connection:state", s), (i = (n = this.config).onConnectionStateChange) == null || i.call(n, s);
+    }), this.connection.on("error", (s) => {
+      var n, i;
+      this.emit("error", s), (i = (n = this.config).onError) == null || i.call(n, s);
+    });
+  }
+  async connect() {
+    if (await this.connection.connect(), !this.conversationManager.conversationId) {
+      const e = await this.api.createConversation({
+        systemPromptId: this.config.systemPromptId,
+        channel: this.config.channel || "widget"
+      });
+      this.conversationManager.conversationId = String(e.id);
+    }
+    this.subscription = await this.connection.subscribeToConversation(
+      this.conversationManager.conversationId
+    ), this.subscription.onReceived((e) => {
+      this.handleBroadcast(e);
+    }), await this.loadHistory();
+  }
+  async sendMessage(e) {
+    var i, c;
+    const s = this.conversationManager.conversationId;
+    if (!s)
+      throw new Error("No active conversation");
+    const n = this.messageStore.addOptimistic("user", e, s);
+    this.emit("message:sent", n), (c = (i = this.config).onMessage) == null || c.call(i, n), this.connection.sendMessage(s, e);
+  }
+  async sendUserEvent(e, s, n) {
+    const i = this.conversationManager.conversationId;
+    if (!i)
+      throw new Error("No active conversation");
+    this.connection.sendUserEvent(i, e, s, n);
+  }
+  async loadHistory() {
+    const e = this.conversationManager.conversationId;
+    if (!e) return [];
+    try {
+      const s = await this.api.getMessages(e);
+      return this.messageStore.setMessages(s), s;
+    } catch {
+      return [];
+    }
+  }
+  get messages() {
+    return this.messageStore.messages;
+  }
+  get conversationId() {
+    return this.conversationManager.conversationId;
+  }
+  get isConnected() {
+    return this.connection.connectionState === "connected";
+  }
+  async disconnect() {
+    this.subscription && (this.subscription = null), await this.connection.disconnect();
+  }
+  handleBroadcast(e) {
+    var n, i, c, d, l, u, g, p;
+    const s = this.conversationManager.conversationId;
+    switch (e.type) {
+      case "status": {
+        const r = e.status;
+        this.emit("status", r), (i = (n = this.config).onStatusChange) == null || i.call(n, r), r === "processing" && this.emit("typing:start", void 0);
+        break;
+      }
+      case "error": {
+        const r = new Error(e.message || "Unknown error");
+        this.emit("error", r), (d = (c = this.config).onError) == null || d.call(c, r);
+        break;
+      }
+      case "message_start": {
+        if (e.role === "assistant") {
+          const r = this.messageStore.addStreamingMessage(s);
+          this.emit("stream:start", { messageId: r.id }), this.emit("typing:start", void 0);
+        }
+        break;
+      }
+      case "message_update": {
+        const r = e.content || "", h = e.delta || "";
+        this.messageStore.updateStreaming(r), this.emit("stream:update", { delta: h, content: r }), (u = (l = this.config).onStreamUpdate) == null || u.call(l, h, r);
+        break;
+      }
+      case "message_end": {
+        const r = e.usage, h = this.messageStore.finalizeStreaming(
+          r ? { tokensInput: r.tokens_input || 0, tokensOutput: r.tokens_output || 0 } : void 0
+        );
+        this.emit("typing:stop", void 0), h && (this.emit("stream:end", {
+          messageId: h.id,
+          usage: r ? { tokensInput: r.tokens_input || 0, tokensOutput: r.tokens_output || 0 } : void 0
+        }), this.emit("message:received", h), (p = (g = this.config).onMessage) == null || p.call(g, h));
+        break;
+      }
+      case "message_queued": {
+        const r = this.messageStore.messages.findLast((h) => h.status === "sending");
+        r && this.messageStore.confirmOptimistic(r.id);
+        break;
+      }
+      case "tool_execution_start":
+      case "tool_execution_update":
+      case "tool_execution_end":
+      case "agent_start":
+      case "agent_end":
+      case "turn_start":
+      case "turn_end":
+      case "auto_retry_start":
+      case "auto_retry_end":
+      case "cancelled":
+        this.emit("status", e.type);
+        break;
+    }
+  }
+}
+export {
+  f as A,
+  S as C,
+  L as D,
+  _ as E,
+  E as M,
+  P as a,
+  I as b,
+  k as c,
+  T as d,
+  R as e,
+  U as f,
+  D as g,
+  C as h,
+  A as i,
+  N as j,
+  O as k,
+  F as l
+};

package/dist/headless.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./headless-CjIUiswe.cjs");exports.ActionCableClient=e.ActionCableClient;exports.AikaaraChatClient=e.AikaaraChatClient;exports.ApiClient=e.ApiClient;exports.ChannelSubscription=e.ChannelSubscription;exports.ConnectionManager=e.ConnectionManager;exports.ConversationManager=e.ConversationManager;exports.EventEmitter=e.EventEmitter;exports.MessageStore=e.MessageStore;