@harnessio/ai-chat-core 0.0.1

package/dist/index.js

@@ -0,0 +1,1051 @@
+var $ = Object.defineProperty;
+var q = (n, i, t) => i in n ? $(n, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[i] = t;
+var d = (n, i, t) => q(n, typeof i != "symbol" ? i + "" : i, t);
+import j, { createContext as U, useContext as J, useState as D, useEffect as k } from "react";
+class W {
+  constructor() {
+    d(this, "plugins", /* @__PURE__ */ new Map());
+    d(this, "renderersByType", /* @__PURE__ */ new Map());
+  }
+  registerPlugin(i) {
+    this.plugins.has(i.id), this.plugins.set(i.id, i), i.renderers.forEach((t) => {
+      const e = this.renderersByType.get(t.type) || [];
+      e.push(t), e.sort((r, s) => ((s == null ? void 0 : s.priority) ?? 0) - ((r == null ? void 0 : r.priority) ?? 0)), this.renderersByType.set(t.type, e);
+    });
+  }
+  unregisterPlugin(i) {
+    const t = this.plugins.get(i);
+    return t ? (t.renderers.forEach((e) => {
+      const s = (this.renderersByType.get(e.type) || []).filter((a) => !t.renderers.includes(a));
+      s.length === 0 ? this.renderersByType.delete(e.type) : this.renderersByType.set(e.type, s);
+    }), this.plugins.delete(i)) : !1;
+  }
+  getPlugin(i) {
+    return this.plugins.get(i);
+  }
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  getRenderersByType(i) {
+    return this.renderersByType.get(i) || [];
+  }
+  getBestRendererForType(i) {
+    return this.getRenderersByType(i)[0];
+  }
+  clear() {
+    this.plugins.clear(), this.renderersByType.clear();
+  }
+}
+class m {
+  constructor() {
+    d(this, "_subscriptions", /* @__PURE__ */ new Set());
+  }
+  subscribe(i) {
+    return this._subscriptions.add(i), () => {
+      this._subscriptions.delete(i);
+    };
+  }
+  notifySubscribers() {
+    for (const i of this._subscriptions)
+      i();
+  }
+  getSubscriberCount() {
+    return this._subscriptions.size;
+  }
+}
+class z extends m {
+  constructor() {
+    super(...arguments);
+    d(this, "_state", {
+      isActive: !1,
+      context: null,
+      focusedContent: null,
+      focusedMessage: null,
+      focusedMessageId: null,
+      focusedContentIndex: null
+    });
+  }
+  get state() {
+    return this._state;
+  }
+  get isActive() {
+    return this._state.isActive;
+  }
+  get context() {
+    return this._state.context;
+  }
+  get focusedContent() {
+    return this._state.focusedContent;
+  }
+  get focusedMessage() {
+    return this._state.focusedMessage;
+  }
+  get focusedMessageId() {
+    return this._state.focusedMessageId;
+  }
+  get focusedContentIndex() {
+    return this._state.focusedContentIndex;
+  }
+  focus(t, e, r, s = "detail") {
+    this._state = {
+      isActive: !0,
+      context: s,
+      focusedContent: t,
+      focusedMessage: e,
+      focusedMessageId: e.id,
+      focusedContentIndex: r
+    }, this.notifySubscribers();
+  }
+  blur() {
+    this._state = {
+      isActive: !1,
+      context: null,
+      focusedContent: null,
+      focusedMessage: null,
+      focusedMessageId: null,
+      focusedContentIndex: null
+    }, this.notifySubscribers();
+  }
+  toggle(t, e, r, s = "detail") {
+    this._state.isActive && this._state.focusedMessageId === e.id && this._state.focusedContentIndex === r && this._state.context === s ? this.blur() : this.focus(t, e, r, s);
+  }
+  switchContext(t) {
+    this._state.isActive && this._state.focusedContent && (this._state = {
+      ...this._state,
+      context: t
+    }, this.notifySubscribers());
+  }
+  focusNext(t) {
+    if (!this._state.focusedMessageId || !t.length) return;
+    const e = t.findIndex((a) => a.id === this._state.focusedMessageId);
+    if (e === -1) return;
+    const r = t[e], s = this._state.focusedContentIndex ?? 0;
+    if (s + 1 < r.content.length) {
+      const a = r.content[s + 1];
+      this.focus(a, r, s + 1, this._state.context || "detail");
+      return;
+    }
+    if (e + 1 < t.length) {
+      const a = t[e + 1];
+      a.content.length > 0 && this.focus(a.content[0], a, 0, this._state.context || "detail");
+    }
+  }
+  focusPrevious(t) {
+    if (!this._state.focusedMessageId || !t.length) return;
+    const e = t.findIndex((a) => a.id === this._state.focusedMessageId);
+    if (e === -1) return;
+    const r = t[e], s = this._state.focusedContentIndex ?? 0;
+    if (s > 0) {
+      const a = r.content[s - 1];
+      this.focus(a, r, s - 1, this._state.context || "detail");
+      return;
+    }
+    if (e > 0) {
+      const a = t[e - 1];
+      if (a.content.length > 0) {
+        const o = a.content.length - 1;
+        this.focus(a.content[o], a, o, this._state.context || "detail");
+      }
+    }
+  }
+}
+let G = 0, V = 0;
+function E() {
+  return `msg-${Date.now()}-${++G}`;
+}
+function M() {
+  return `thread-${Date.now()}-${++V}`;
+}
+function ct(n = "id") {
+  return `${n}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+class w extends m {
+  constructor(t) {
+    super();
+    d(this, "_state");
+    this.config = t, this._state = t.state;
+  }
+  get state() {
+    return this._state;
+  }
+  getState() {
+    return this._state;
+  }
+  updateState(t) {
+    this._state = t, this.notifySubscribers();
+  }
+  async switchTo() {
+    await this.config.onSwitchTo(this._state.id);
+  }
+  async rename(t) {
+    await this.config.onRename(this._state.id, t);
+  }
+  async delete() {
+    await this.config.onDelete(this._state.id);
+  }
+  subscribe(t) {
+    return super.subscribe(t);
+  }
+}
+class H extends m {
+  constructor() {
+    super(...arguments);
+    d(this, "_text", "");
+    d(this, "_isSubmitting", !1);
+  }
+  get text() {
+    return this._text;
+  }
+  get isSubmitting() {
+    return this._isSubmitting;
+  }
+  getState() {
+    return {
+      text: this._text,
+      isSubmitting: this._isSubmitting
+    };
+  }
+  setText(t) {
+    this._text = t, this.notifySubscribers();
+  }
+  clear() {
+    this._text = "", this.notifySubscribers();
+  }
+  setSubmitting(t) {
+    this._isSubmitting = t, this.notifySubscribers();
+  }
+}
+class T extends m {
+  constructor(t) {
+    super();
+    d(this, "composer");
+    this._core = t, this.composer = new H(), this._core.subscribe(() => {
+      this.notifySubscribers();
+    });
+  }
+  get messages() {
+    return this._core.messages;
+  }
+  get isRunning() {
+    return this._core.isRunning;
+  }
+  get isDisabled() {
+    return this._core.isDisabled;
+  }
+  get capabilities() {
+    return this._core.capabilities;
+  }
+  getState() {
+    return {
+      threadId: "main",
+      // Will be set by ThreadListRuntime
+      isDisabled: this._core.isDisabled,
+      isRunning: this._core.isRunning,
+      capabilities: this._core.capabilities
+    };
+  }
+  append(t) {
+    this._core.append(t);
+  }
+  async send(t) {
+    if (t.trim()) {
+      this.composer.setSubmitting(!0);
+      try {
+        this.composer.clear(), await this._core.startRun({
+          role: "user",
+          content: [{ type: "text", data: t }]
+        });
+      } catch {
+      } finally {
+        this.composer.setSubmitting(!1);
+      }
+    }
+  }
+  cancelRun() {
+    this._core.cancelRun();
+  }
+  clear() {
+    this._core.clear();
+  }
+  reset(t = []) {
+    this._core.reset(t);
+  }
+  subscribe(t) {
+    return super.subscribe(t);
+  }
+}
+class x extends m {
+  constructor(t) {
+    super();
+    d(this, "_messages", []);
+    d(this, "_isRunning", !1);
+    d(this, "_isDisabled", !1);
+    d(this, "_abortController", null);
+    // Track current part being accumulated
+    d(this, "_currentPart", null);
+    this.config = t, t.initialMessages && (this._messages = [...t.initialMessages]);
+  }
+  get messages() {
+    return this._messages;
+  }
+  get isRunning() {
+    return this._isRunning;
+  }
+  get isDisabled() {
+    return this._isDisabled;
+  }
+  get capabilities() {
+    return {
+      cancel: !0,
+      edit: !1,
+      reload: !1,
+      speech: !1,
+      attachments: !1,
+      feedback: !1
+    };
+  }
+  append(t) {
+    var r, s;
+    const e = {
+      id: t.id || E(),
+      parentId: t.parentId,
+      role: t.role,
+      content: t.content,
+      status: t.status || { type: "complete" },
+      timestamp: t.timestamp || Date.now(),
+      metadata: t.metadata
+    };
+    this._messages.push(e), (s = (r = this.config).onMessagesChange) == null || s.call(r, this._messages), this.notifySubscribers();
+  }
+  async startRun(t) {
+    var s, a;
+    if (this._isRunning)
+      throw new Error("A run is already in progress");
+    this.append(t), this._isRunning = !0, this._abortController = new AbortController(), this._currentPart = null, this.notifySubscribers();
+    const e = E(), r = {
+      id: e,
+      role: "assistant",
+      content: [],
+      status: { type: "running" },
+      timestamp: Date.now()
+    };
+    this._messages.push(r), (a = (s = this.config).onMessagesChange) == null || a.call(s, this._messages), this.notifySubscribers();
+    try {
+      const o = this.config.streamAdapter.stream({
+        messages: this._messages,
+        signal: this._abortController.signal
+      });
+      for await (const u of o) {
+        if (this._abortController.signal.aborted)
+          break;
+        this.handleStreamEvent(e, u.event);
+      }
+      this.updateMessageStatus(e, { type: "complete" });
+    } catch (o) {
+      if (o instanceof Error && o.name === "AbortError")
+        this.updateMessageStatus(e, { type: "cancelled" });
+      else {
+        const u = o instanceof Error ? o.message : "Unknown error";
+        this.updateMessageStatus(e, {
+          type: "error",
+          error: u
+        });
+      }
+    } finally {
+      this._isRunning = !1, this._abortController = null, this._currentPart = null, this.notifySubscribers();
+    }
+  }
+  handleStreamEvent(t, e) {
+    var a, o;
+    const r = this._messages.findIndex((u) => u.id === t);
+    if (r === -1) return;
+    const s = this._messages[r];
+    if (e.type === "part-start")
+      this.handlePartStart(s, e);
+    else if (e.type === "text-delta")
+      this.handleTextDelta(s, e);
+    else if (e.type === "part-finish")
+      this.handlePartFinish();
+    else if (e.type === "metadata") {
+      const u = e;
+      s.metadata = {
+        ...s.metadata,
+        conversationId: u.conversationId,
+        interactionId: u.interactionId
+      };
+    } else if (e.type === "error") {
+      const u = e;
+      s.content.push({
+        type: "error",
+        data: u.error
+      });
+    } else {
+      const u = e;
+      s.content.push({
+        type: u.type,
+        data: u.data,
+        parentId: u.parentId
+      });
+    }
+    this._messages = [
+      ...this._messages.slice(0, r),
+      { ...s, timestamp: Date.now() },
+      ...this._messages.slice(r + 1)
+    ], (o = (a = this.config).onMessagesChange) == null || o.call(a, this._messages), this.notifySubscribers();
+  }
+  handlePartStart(t, e) {
+    const r = t.content.length;
+    let s;
+    switch (e.part.type) {
+      case "assistant_thought":
+        s = {
+          type: e.part.type,
+          data: [],
+          parentId: e.part.parentId
+        };
+        break;
+      case "text":
+        s = {
+          type: e.part.type,
+          data: "",
+          parentId: e.part.parentId
+        };
+        break;
+      default:
+        s = {
+          type: e.part.type,
+          parentId: e.part.parentId
+        };
+    }
+    t.content.push(s), this._currentPart = {
+      messageId: t.id,
+      contentIndex: r,
+      type: e.part.type,
+      parentId: e.part.parentId
+    };
+  }
+  handleTextDelta(t, e) {
+    if (!this._currentPart) {
+      console.warn("Received text-delta without part-start");
+      return;
+    }
+    const r = t.content[this._currentPart.contentIndex];
+    r.type === "assistant_thought" ? (Array.isArray(r.data) || (r.data = []), e.delta.trim() && r.data.push(e.delta.trim())) : r.data = (r.data || "") + e.delta;
+  }
+  handlePartFinish() {
+    if (!this._currentPart) {
+      console.warn("Received part-finish without part-start");
+      return;
+    }
+    this._currentPart = null;
+  }
+  updateMessageStatus(t, e) {
+    var s, a;
+    const r = this._messages.findIndex((o) => o.id === t);
+    r !== -1 && (this._messages[r] = {
+      ...this._messages[r],
+      status: e
+    }, (a = (s = this.config).onMessagesChange) == null || a.call(s, this._messages), this.notifySubscribers());
+  }
+  clear() {
+    var t, e;
+    this._messages = [], (e = (t = this.config).onMessagesChange) == null || e.call(t, this._messages), this.notifySubscribers();
+  }
+  cancelRun() {
+    !this._isRunning || !this._abortController || this._abortController.abort();
+  }
+  reset(t = []) {
+    var e, r;
+    this._messages = [...t], (r = (e = this.config).onMessagesChange) == null || r.call(e, this._messages), this.notifySubscribers();
+  }
+}
+class K extends m {
+  constructor(t) {
+    super();
+    d(this, "_mainThreadId");
+    d(this, "_threads", /* @__PURE__ */ new Map());
+    d(this, "_threadItems", /* @__PURE__ */ new Map());
+    d(this, "_threadStates", /* @__PURE__ */ new Map());
+    d(this, "_isLoading", !1);
+    d(this, "main");
+    this.config = t, this._mainThreadId = M();
+    const e = new x({
+      streamAdapter: t.streamAdapter
+    });
+    this.main = new T(e), this._threads.set(this._mainThreadId, this.main);
+    const r = {
+      id: this._mainThreadId,
+      title: "New Chat",
+      status: { type: "regular" },
+      isMain: !0,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this._threadStates.set(this._mainThreadId, r);
+    const s = new w({
+      state: r,
+      onSwitchTo: this.switchToThread.bind(this),
+      onRename: this.renameThread.bind(this),
+      onDelete: this.deleteThread.bind(this)
+    });
+    this._threadItems.set(this._mainThreadId, s);
+  }
+  get isLoading() {
+    return this._isLoading;
+  }
+  /**
+   * Get the currently active main thread
+   */
+  getMainThread() {
+    const t = this._threads.get(this._mainThreadId);
+    return t || this.main;
+  }
+  getState() {
+    const t = [], e = {};
+    for (const [r, s] of this._threadStates)
+      e[r] = s, s.status.type === "regular" && t.push(r);
+    return {
+      mainThreadId: this._mainThreadId,
+      threads: t,
+      isLoading: this._isLoading,
+      threadItems: e
+    };
+  }
+  async switchToThread(t) {
+    var a, o;
+    const e = this._threads.get(t);
+    if (!e)
+      throw new Error(`Thread ${t} not found`);
+    const r = this._threadStates.get(this._mainThreadId);
+    r && (r.isMain = !1, this._threadStates.set(this._mainThreadId, r), (a = this._threadItems.get(this._mainThreadId)) == null || a.updateState(r)), this._mainThreadId = t;
+    const s = this._threadStates.get(t);
+    if (s && (s.isMain = !0, this._threadStates.set(t, s), (o = this._threadItems.get(t)) == null || o.updateState(s)), this.config.threadListAdapter && (s != null && s.conversationId)) {
+      this._isLoading = !0, this.notifySubscribers();
+      try {
+        const u = await this.config.threadListAdapter.loadThread(t);
+        e.reset(u);
+      } catch (u) {
+        console.error("Failed to load thread:", u);
+      } finally {
+        this._isLoading = !1;
+      }
+    }
+    this.notifySubscribers();
+  }
+  async switchToNewThread() {
+    const t = M(), e = new x({
+      streamAdapter: this.config.streamAdapter
+    }), r = new T(e);
+    this._threads.set(t, r);
+    const s = {
+      id: t,
+      title: "New Chat",
+      status: { type: "regular" },
+      isMain: !1,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+    this._threadStates.set(t, s);
+    const a = new w({
+      state: s,
+      onSwitchTo: this.switchToThread.bind(this),
+      onRename: this.renameThread.bind(this),
+      onDelete: this.deleteThread.bind(this)
+    });
+    if (this._threadItems.set(t, a), r.subscribe(() => {
+      this.notifySubscribers();
+    }), this.config.threadListAdapter)
+      try {
+        const o = await this.config.threadListAdapter.createThread();
+        s.conversationId = o.conversationId, this._threadStates.set(t, s), a.updateState(s);
+      } catch (o) {
+        console.error("Failed to create thread:", o);
+      }
+    await this.switchToThread(t);
+  }
+  async loadThreads() {
+    if (!this.config.threadListAdapter) {
+      console.warn("No threadListAdapter configured");
+      return;
+    }
+    this._isLoading = !0, this.notifySubscribers();
+    try {
+      const t = await this.config.threadListAdapter.loadThreads();
+      for (const e of t) {
+        if (this._threadStates.has(e.id))
+          continue;
+        const r = new x({
+          streamAdapter: this.config.streamAdapter
+        }), s = new T(r);
+        this._threads.set(e.id, s), this._threadStates.set(e.id, e);
+        const a = new w({
+          state: e,
+          onSwitchTo: this.switchToThread.bind(this),
+          onRename: this.renameThread.bind(this),
+          onDelete: this.deleteThread.bind(this)
+        });
+        this._threadItems.set(e.id, a), s.subscribe(() => {
+          this.notifySubscribers();
+        });
+      }
+    } catch (t) {
+      console.error("Failed to load threads:", t);
+    } finally {
+      this._isLoading = !1, this.notifySubscribers();
+    }
+  }
+  async renameThread(t, e) {
+    var s;
+    const r = this._threadStates.get(t);
+    if (r) {
+      if (r.title = e, r.updatedAt = Date.now(), this._threadStates.set(t, r), (s = this._threadItems.get(t)) == null || s.updateState(r), this.config.threadListAdapter)
+        try {
+          await this.config.threadListAdapter.updateThread(t, { title: e });
+        } catch (a) {
+          console.error("Failed to rename thread:", a);
+        }
+      this.notifySubscribers();
+    }
+  }
+  async deleteThread(t) {
+    if (t === this._mainThreadId && this._threads.size === 1)
+      throw new Error("Cannot delete the last thread");
+    if (t === this._mainThreadId) {
+      const e = Array.from(this._threads.keys()).find((r) => r !== t);
+      e && await this.switchToThread(e);
+    }
+    if (this._threads.delete(t), this._threadItems.delete(t), this._threadStates.delete(t), this.config.threadListAdapter)
+      try {
+        await this.config.threadListAdapter.deleteThread(t);
+      } catch (e) {
+        console.error("Failed to delete thread:", e);
+      }
+    this.notifySubscribers();
+  }
+}
+class ht extends m {
+  constructor(t) {
+    super();
+    d(this, "threads");
+    d(this, "pluginRegistry");
+    d(this, "_contentFocusRuntime");
+    d(this, "_currentThreadUnsubscribe");
+    this.pluginRegistry = new W(), t.plugins && t.plugins.forEach((e) => {
+      this.pluginRegistry.registerPlugin(e);
+    }), this.threads = new K({
+      streamAdapter: t.streamAdapter,
+      threadListAdapter: t.threadListAdapter
+    }), this._contentFocusRuntime = new z(), this._contentFocusRuntime.subscribe(() => {
+      this.notifySubscribers();
+    }), this.threads.subscribe(() => {
+      this.subscribeToCurrentThread(), this.notifySubscribers();
+    }), this.subscribeToCurrentThread();
+  }
+  get thread() {
+    return this.threads.getMainThread();
+  }
+  get contentFocus() {
+    return this._contentFocusRuntime;
+  }
+  /**
+   * Register a plugin
+   */
+  registerPlugin(t) {
+    var e;
+    this.pluginRegistry.registerPlugin(t), (e = t.init) == null || e.call(t, {
+      streamingEnabled: !0,
+      feedbackEnabled: !1,
+      detailPanelEnabled: !0
+    });
+  }
+  /**
+   * Unregister a plugin
+   */
+  unregisterPlugin(t) {
+    return this.pluginRegistry.unregisterPlugin(t);
+  }
+  /**
+   * Subscribe to the current main thread
+   * Called when thread switches to ensure we listen to the right thread
+   */
+  subscribeToCurrentThread() {
+    this._currentThreadUnsubscribe && this._currentThreadUnsubscribe(), this._currentThreadUnsubscribe = this.thread.subscribe(() => {
+      this.handleMessagesChange(this.thread.messages), this.notifySubscribers();
+    });
+  }
+  handleMessagesChange(t) {
+    if (t.length === 0) return;
+    const e = t[t.length - 1];
+    e.role === "assistant" && e.status.type === "complete" && this.autoFocusLastContent(t);
+  }
+  autoFocusLastContent(t) {
+    var e;
+    if (t.length !== 0 && !this._contentFocusRuntime.isActive)
+      for (let r = t.length - 1; r >= 0; r--) {
+        const s = t[r];
+        if (s.role === "assistant")
+          for (let a = s.content.length - 1; a >= 0; a--) {
+            const o = s.content[a], u = this.pluginRegistry.getRenderersByType(o.type);
+            if (u.length > 0 && ((e = u[0].capabilities) != null && e.supportsFocus)) {
+              this._contentFocusRuntime.focus(o, s, a, "detail");
+              return;
+            }
+          }
+      }
+  }
+}
+var I = { exports: {} }, _ = {};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var R, A;
+function Y() {
+  if (A) return R;
+  A = 1;
+  var n = Object.getOwnPropertySymbols, i = Object.prototype.hasOwnProperty, t = Object.prototype.propertyIsEnumerable;
+  function e(s) {
+    if (s == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(s);
+  }
+  function r() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var s = new String("abc");
+      if (s[5] = "de", Object.getOwnPropertyNames(s)[0] === "5")
+        return !1;
+      for (var a = {}, o = 0; o < 10; o++)
+        a["_" + String.fromCharCode(o)] = o;
+      var u = Object.getOwnPropertyNames(a).map(function(l) {
+        return a[l];
+      });
+      if (u.join("") !== "0123456789")
+        return !1;
+      var f = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(l) {
+        f[l] = l;
+      }), Object.keys(Object.assign({}, f)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return R = r() ? Object.assign : function(s, a) {
+    for (var o, u = e(s), f, l = 1; l < arguments.length; l++) {
+      o = Object(arguments[l]);
+      for (var c in o)
+        i.call(o, c) && (u[c] = o[c]);
+      if (n) {
+        f = n(o);
+        for (var h = 0; h < f.length; h++)
+          t.call(o, f[h]) && (u[f[h]] = o[f[h]]);
+      }
+    }
+    return u;
+  }, R;
+}
+/** @license React v17.0.2
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var P;
+function Q() {
+  if (P) return _;
+  P = 1, Y();
+  var n = j, i = 60103;
+  if (_.Fragment = 60107, typeof Symbol == "function" && Symbol.for) {
+    var t = Symbol.for;
+    i = t("react.element"), _.Fragment = t("react.fragment");
+  }
+  var e = n.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, r = Object.prototype.hasOwnProperty, s = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function a(o, u, f) {
+    var l, c = {}, h = null, p = null;
+    f !== void 0 && (h = "" + f), u.key !== void 0 && (h = "" + u.key), u.ref !== void 0 && (p = u.ref);
+    for (l in u) r.call(u, l) && !s.hasOwnProperty(l) && (c[l] = u[l]);
+    if (o && o.defaultProps) for (l in u = o.defaultProps, u) c[l] === void 0 && (c[l] = u[l]);
+    return { $$typeof: i, type: o, key: h, ref: p, props: c, _owner: e.current };
+  }
+  return _.jsx = a, _.jsxs = a, _;
+}
+var F;
+function X() {
+  return F || (F = 1, I.exports = Q()), I.exports;
+}
+var Z = X();
+const B = U(null);
+function dt({ runtime: n, children: i }) {
+  return /* @__PURE__ */ Z.jsx(B.Provider, { value: n, children: i });
+}
+function tt() {
+  const n = J(B);
+  if (!n)
+    throw new Error("useAssistantRuntimeContext must be used within AssistantRuntimeProvider");
+  return n;
+}
+function y() {
+  return tt();
+}
+function lt() {
+  const n = y();
+  return {
+    switchToThread: (i) => n.threads.switchToThread(i),
+    switchToNewThread: () => n.threads.switchToNewThread(),
+    loadThreads: () => {
+      var i, t;
+      return (t = (i = n.threads).loadThreads) == null ? void 0 : t.call(i);
+    },
+    renameThread: (i, t) => {
+      var e, r;
+      return (r = (e = n.threads).renameThread) == null ? void 0 : r.call(e, i, t);
+    },
+    deleteThread: (i) => {
+      var t, e;
+      return (e = (t = n.threads).deleteThread) == null ? void 0 : e.call(t, i);
+    }
+  };
+}
+function ft() {
+  const n = y(), [i, t] = D(n.threads.getState());
+  return k(() => n.threads.subscribe(() => {
+    t(n.threads.getState());
+  }), [n]), i;
+}
+function et() {
+  return y().threads.getMainThread();
+}
+var C = { exports: {} }, v = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var L;
+function st() {
+  if (L) return v;
+  L = 1;
+  var n = j;
+  function i(c, h) {
+    return c === h && (c !== 0 || 1 / c === 1 / h) || c !== c && h !== h;
+  }
+  var t = typeof Object.is == "function" ? Object.is : i, e = n.useState, r = n.useEffect, s = n.useLayoutEffect, a = n.useDebugValue;
+  function o(c, h) {
+    var p = h(), b = e({ inst: { value: p, getSnapshot: h } }), g = b[0].inst, S = b[1];
+    return s(
+      function() {
+        g.value = p, g.getSnapshot = h, u(g) && S({ inst: g });
+      },
+      [c, p, h]
+    ), r(
+      function() {
+        return u(g) && S({ inst: g }), c(function() {
+          u(g) && S({ inst: g });
+        });
+      },
+      [c]
+    ), a(p), p;
+  }
+  function u(c) {
+    var h = c.getSnapshot;
+    c = c.value;
+    try {
+      var p = h();
+      return !t(c, p);
+    } catch {
+      return !0;
+    }
+  }
+  function f(c, h) {
+    return h();
+  }
+  var l = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? f : o;
+  return v.useSyncExternalStore = n.useSyncExternalStore !== void 0 ? n.useSyncExternalStore : l, v;
+}
+var O;
+function rt() {
+  return O || (O = 1, C.exports = st()), C.exports;
+}
+var N = rt();
+function pt() {
+  const n = y();
+  return N.useSyncExternalStore(
+    (i) => n.subscribe(() => {
+      i();
+    }),
+    () => n.thread.messages,
+    () => n.thread.messages
+  );
+}
+function nt() {
+  return et().composer;
+}
+function gt() {
+  const n = nt();
+  return N.useSyncExternalStore(
+    (i) => n.subscribe(i),
+    () => n.getState(),
+    () => n.getState()
+  );
+}
+function mt(n, i) {
+  var s, a, o, u;
+  const e = y().pluginRegistry.getBestRendererForType(n);
+  if (!e)
+    return {
+      component: null,
+      auxiliaryComponent: null,
+      supportsFocus: !1,
+      supportsPreview: !1,
+      supportsFullscreen: !1
+    };
+  const r = i ? (s = e.auxiliary) == null ? void 0 : s[i] : null;
+  return {
+    component: e.component,
+    auxiliaryComponent: r,
+    supportsFocus: ((a = e.capabilities) == null ? void 0 : a.supportsFocus) ?? !1,
+    supportsPreview: ((o = e.capabilities) == null ? void 0 : o.supportsPreview) ?? !1,
+    supportsFullscreen: ((u = e.capabilities) == null ? void 0 : u.supportsFullscreen) ?? !1
+  };
+}
+function bt() {
+  const n = y(), [i, t] = D(n.contentFocus.state);
+  return k(() => n.contentFocus.subscribe(() => {
+    t(n.contentFocus.state);
+  }), [n]), {
+    ...i,
+    focus: (e, r, s, a) => n.contentFocus.focus(e, r, s, a),
+    blur: () => n.contentFocus.blur(),
+    toggle: (e, r, s, a) => n.contentFocus.toggle(e, r, s, a),
+    switchContext: (e) => n.contentFocus.switchContext(e),
+    focusNext: () => n.contentFocus.focusNext(n.thread.messages),
+    focusPrevious: () => n.contentFocus.focusPrevious(n.thread.messages)
+  };
+}
+function _t(n) {
+  const i = /* @__PURE__ */ new Map();
+  for (let e = 0; e < n.length; e++) {
+    const a = n[e].parentId ?? `__ungrouped_${e}`, o = i.get(a) ?? [];
+    o.push(e), i.set(a, o);
+  }
+  const t = [];
+  for (const [e, r] of i) {
+    const s = e.startsWith("__ungrouped_") ? void 0 : e, a = r.map((f) => n[f]), o = it(a), u = at(a);
+    t.push({ groupKey: s, indices: r, items: a, groupType: o, primaryType: u });
+  }
+  return t;
+}
+function it(n) {
+  if (n.length === 1) return "single-type";
+  if (new Set(n.map((t) => t.type)).size === 1) {
+    const t = n[0].type;
+    return t === "tool_call" ? "tool-calls" : t === "assistant_thought" ? "reasoning" : "single-type";
+  }
+  return "mixed";
+}
+function at(n) {
+  const i = /* @__PURE__ */ new Map();
+  for (const r of n)
+    i.set(r.type, (i.get(r.type) || 0) + 1);
+  let t = 0, e = n[0].type;
+  for (const [r, s] of i)
+    s > t && (t = s, e = r);
+  return e;
+}
+class yt {
+  getAllowedEvents() {
+    return null;
+  }
+  shouldProcessEvent(i) {
+    const t = this.getAllowedEvents();
+    return t ? t.includes(i) : !0;
+  }
+  async *stream(i) {
+    const { signal: t } = i, { url: e, options: r } = this.prepareRequest(i), s = await fetch(e, { ...r, signal: t });
+    if (!s.ok)
+      throw new Error(`HTTP error! status: ${s.status}`);
+    if (!s.body)
+      throw new Error("Response body is null");
+    yield* this.parseSSEStream(s.body, t);
+  }
+  async *parseSSEStream(i, t) {
+    const e = i.getReader(), r = new TextDecoder();
+    let s = "", a = null;
+    try {
+      for (; ; ) {
+        const { done: o, value: u } = await e.read();
+        if (o || t != null && t.aborted) break;
+        s += r.decode(u, { stream: !0 });
+        const f = s.split(`
+`);
+        s = f.pop() || "";
+        for (const l of f) {
+          const c = l.trim();
+          if (!c) {
+            a = null;
+            continue;
+          }
+          if (c !== ": ping") {
+            if (c.startsWith("event:")) {
+              a = c.substring(6).trim();
+              continue;
+            }
+            if (c.startsWith("data:")) {
+              const h = c.substring(5).trim();
+              if (h === "eof" || c === "eof")
+                break;
+              try {
+                const p = JSON.parse(h);
+                if (a && this.shouldProcessEvent(a)) {
+                  const b = this.convertEvent({
+                    event: a,
+                    data: p
+                  });
+                  b && (yield b);
+                }
+              } catch {
+              }
+              a = null;
+            }
+          }
+        }
+      }
+    } finally {
+      e.releaseLock();
+    }
+  }
+}
+export {
+  ht as AssistantRuntime,
+  dt as AssistantRuntimeProvider,
+  yt as BaseSSEStreamAdapter,
+  m as BaseSubscribable,
+  H as ComposerRuntime,
+  W as PluginRegistry,
+  w as ThreadListItemRuntime,
+  K as ThreadListRuntime,
+  T as ThreadRuntime,
+  x as ThreadRuntimeCore,
+  ct as generateId,
+  E as generateMessageId,
+  M as generateThreadId,
+  _t as groupContentByParentId,
+  y as useAssistantRuntime,
+  nt as useComposer,
+  gt as useComposerState,
+  bt as useContentFocus,
+  mt as useContentRenderer,
+  et as useCurrentThread,
+  pt as useMessages,
+  lt as useThreadList,
+  ft as useThreadListState
+};
+//# sourceMappingURL=index.js.map