@amodalai/react 0.1.0 → 0.1.2

package/dist/client.js

@@ -1,140 +1,79 @@
-var m = Object.defineProperty;
-var S = (s, e, t) => e in s ? m(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var d = (s, e, t) => S(s, typeof e != "symbol" ? e + "" : e, t);
+var g = Object.defineProperty;
+var k = (h, s, t) => s in h ? g(h, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[s] = t;
+var n = (h, s, t) => k(h, typeof s != "symbol" ? s + "" : s, t);
+import { b as p, e as w, s as f, T as y, W as S, a as b } from "./event-bus-h26clqbZ.js";
+import { c as A, g as T, l as B, p as P, u as N } from "./event-bus-h26clqbZ.js";
 /**
  * @license
  * Copyright 2025 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
-function l(s) {
-  if (!s.startsWith("data: ")) return null;
-  const e = s.slice(6).trim();
-  return e.length === 0 ? null : JSON.parse(e);
-}
-async function* g(s, e, t) {
-  const a = {
-    "Content-Type": "application/json",
-    ...t == null ? void 0 : t.headers
-  }, r = await fetch(s, {
-    method: "POST",
-    headers: a,
-    body: JSON.stringify(e),
-    signal: t == null ? void 0 : t.signal
-  });
-  if (!r.ok)
-    throw new Error(`SSE request failed: ${String(r.status)} ${r.statusText}`);
-  yield* f(r);
-}
-async function* y(s, e) {
-  const t = await fetch(s, {
-    method: "GET",
-    headers: e == null ? void 0 : e.headers,
-    signal: e == null ? void 0 : e.signal
-  });
-  if (!t.ok)
-    throw new Error(`SSE request failed: ${String(t.status)} ${t.statusText}`);
-  yield* f(t);
-}
-async function* f(s) {
-  const e = s.body;
-  if (!e)
-    throw new Error("Response body is null");
-  const t = e.getReader(), a = new TextDecoder();
-  let r = "";
-  try {
-    for (; ; ) {
-      const { done: n, value: i } = await t.read();
-      if (n) break;
-      r += a.decode(i, { stream: !0 });
-      const c = r.split(`
-`);
-      r = c.pop() ?? "";
-      for (const w of c) {
-        const h = w.trim();
-        if (h.length === 0) continue;
-        const u = l(h);
-        u && (yield u);
-      }
-    }
-    if (r.trim().length > 0) {
-      const n = l(r.trim());
-      n && (yield n);
-    }
-  } finally {
-    t.releaseLock();
-  }
-}
-/**
- * @license
- * Copyright 2025 Amodal Labs, Inc.
- * SPDX-License-Identifier: MIT
- */
-class $ {
-  constructor(e) {
-    d(this, "runtimeUrl");
-    d(this, "tenantId");
-    d(this, "getToken");
-    this.runtimeUrl = e.runtimeUrl.replace(/\/$/, ""), this.tenantId = e.tenantId, this.getToken = e.getToken;
+class x {
+  constructor(s) {
+    n(this, "runtimeUrl");
+    n(this, "tenantId");
+    n(this, "getToken");
+    this.runtimeUrl = s.runtimeUrl.replace(/\/$/, ""), this.tenantId = s.tenantId, this.getToken = s.getToken;
   }
   async authHeaders() {
-    const e = {};
+    const s = {};
     if (this.getToken) {
       const t = await this.getToken();
-      t && (e.Authorization = `Bearer ${t}`);
+      t && (s.Authorization = `Bearer ${t}`);
     }
-    return e;
+    return s;
   }
   /**
    * Stream a chat message via POST /chat.
    */
-  async *chatStream(e, t) {
-    const a = `${this.runtimeUrl}/chat`, r = {
-      message: e,
+  async *chatStream(s, t) {
+    const e = `${this.runtimeUrl}/chat`, a = {
+      message: s,
       tenant_id: this.tenantId
     };
-    t != null && t.sessionId && (r.session_id = t.sessionId), t != null && t.context && (r.context = t.context);
-    const n = await this.authHeaders();
-    yield* g(a, r, {
+    t != null && t.sessionId && (a.session_id = t.sessionId), t != null && t.context && (a.context = t.context);
+    const o = await this.authHeaders();
+    yield* p(e, a, {
       signal: t == null ? void 0 : t.signal,
-      headers: n
+      headers: o
     });
   }
   /**
    * Start a fire-and-forget task via POST /task.
    */
-  async startTask(e, t) {
-    const a = `${this.runtimeUrl}/task`, r = await this.authHeaders(), n = {
-      prompt: e,
+  async startTask(s, t) {
+    const e = `${this.runtimeUrl}/task`, a = await this.authHeaders(), o = {
+      prompt: s,
       tenant_id: this.tenantId
     };
-    t && (n.tenant_token = t);
-    const i = await fetch(a, {
+    t && (o.tenant_token = t);
+    const l = await fetch(e, {
       method: "POST",
-      headers: { "Content-Type": "application/json", ...r },
-      body: JSON.stringify(n)
+      headers: { "Content-Type": "application/json", ...a },
+      body: JSON.stringify(o)
     });
-    if (!i.ok)
-      throw new Error(`Start task failed: ${String(i.status)} ${i.statusText}`);
-    return await i.json();
+    if (!l.ok)
+      throw new Error(`Start task failed: ${String(l.status)} ${l.statusText}`);
+    return await l.json();
   }
   /**
    * Get task status via GET /task/:id.
    */
-  async getTaskStatus(e) {
-    const t = `${this.runtimeUrl}/task/${e}`, a = await this.authHeaders(), r = await fetch(t, {
+  async getTaskStatus(s) {
+    const t = `${this.runtimeUrl}/task/${s}`, e = await this.authHeaders(), a = await fetch(t, {
       method: "GET",
-      headers: a
+      headers: e
     });
-    if (!r.ok)
-      throw new Error(`Get task status failed: ${String(r.status)} ${r.statusText}`);
-    return await r.json();
+    if (!a.ok)
+      throw new Error(`Get task status failed: ${String(a.status)} ${a.statusText}`);
+    return await a.json();
   }
   /**
    * Stream task events via GET /task/:id/stream.
    */
-  async *streamTask(e, t) {
-    const a = `${this.runtimeUrl}/task/${e}/stream`, r = await this.authHeaders();
-    yield* y(a, { signal: t, headers: r });
+  async *streamTask(s, t) {
+    const e = `${this.runtimeUrl}/task/${s}/stream`, a = await this.authHeaders();
+    yield* w(e, { signal: t, headers: a });
   }
   // ---------------------------------------------------------------------------
   // Store API
@@ -142,40 +81,415 @@ class $ {
   /**
    * List all store definitions with document counts.
    */
-  async getStores(e) {
-    const t = `${this.runtimeUrl}/api/stores`, a = await this.authHeaders(), r = await fetch(t, { headers: a, signal: e });
-    if (!r.ok)
-      throw new Error(`Failed to fetch stores: ${String(r.status)}`);
-    return (await r.json()).stores;
+  async getStores(s) {
+    const t = `${this.runtimeUrl}/api/stores`, e = await this.authHeaders(), a = await fetch(t, { headers: e, signal: s });
+    if (!a.ok)
+      throw new Error(`Failed to fetch stores: ${String(a.status)}`);
+    return (await a.json()).stores;
   }
   /**
    * List documents from a store with optional filtering.
    */
-  async getStoreDocuments(e, t) {
-    const a = new URLSearchParams();
-    t != null && t.filter && a.set("filter", JSON.stringify(t.filter)), t != null && t.sort && a.set("sort", t.sort), (t == null ? void 0 : t.limit) !== void 0 && a.set("limit", String(t.limit)), (t == null ? void 0 : t.offset) !== void 0 && a.set("offset", String(t.offset));
-    const r = a.toString(), n = `${this.runtimeUrl}/api/stores/${e}${r ? `?${r}` : ""}`, i = await this.authHeaders(), c = await fetch(n, { headers: i, signal: t == null ? void 0 : t.signal });
-    if (!c.ok)
-      throw new Error(`Failed to fetch store documents: ${String(c.status)}`);
-    return await c.json();
+  async getStoreDocuments(s, t) {
+    const e = new URLSearchParams();
+    t != null && t.filter && e.set("filter", JSON.stringify(t.filter)), t != null && t.sort && e.set("sort", t.sort), (t == null ? void 0 : t.limit) !== void 0 && e.set("limit", String(t.limit)), (t == null ? void 0 : t.offset) !== void 0 && e.set("offset", String(t.offset));
+    const a = e.toString(), o = `${this.runtimeUrl}/api/stores/${s}${a ? `?${a}` : ""}`, l = await this.authHeaders(), r = await fetch(o, { headers: l, signal: t == null ? void 0 : t.signal });
+    if (!r.ok)
+      throw new Error(`Failed to fetch store documents: ${String(r.status)}`);
+    return await r.json();
   }
   /**
    * Get a single document by key, optionally with version history.
    */
-  async getStoreDocument(e, t, a) {
-    const r = `${this.runtimeUrl}/api/stores/${e}/${encodeURIComponent(t)}`, n = await this.authHeaders(), i = await fetch(r, { headers: n, signal: a });
-    if (!i.ok) {
-      if (i.status === 404)
+  async getStoreDocument(s, t, e) {
+    const a = `${this.runtimeUrl}/api/stores/${s}/${encodeURIComponent(t)}`, o = await this.authHeaders(), l = await fetch(a, { headers: o, signal: e });
+    if (!l.ok) {
+      if (l.status === 404)
         return { document: null, history: [] };
-      throw new Error(`Failed to fetch store document: ${String(i.status)}`);
+      throw new Error(`Failed to fetch store document: ${String(l.status)}`);
+    }
+    return await l.json();
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+class C {
+  constructor(s, t, e) {
+    n(this, "handlers", {
+      text: [],
+      tool_call: [],
+      tool_result: [],
+      skill_activated: [],
+      kb_proposal: [],
+      widget: [],
+      ask_user: [],
+      error: [],
+      done: []
+    });
+    n(this, "abortController");
+    n(this, "started", !1);
+    n(this, "response", {
+      text: "",
+      toolCalls: [],
+      skillsUsed: [],
+      kbProposals: []
+    });
+    n(this, "toolCallNames", /* @__PURE__ */ new Map());
+    n(this, "token");
+    this.serverUrl = s, this.request = t, this.abortController = new AbortController(), this.token = e, queueMicrotask(() => this.start());
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- overload implementation requires broad type
+  on(s, t) {
+    const e = s;
+    return e in this.handlers && this.handlers[e].push(t), this;
+  }
+  /** Cancel the stream. */
+  abort() {
+    this.abortController.abort();
+  }
+  async start() {
+    if (!this.started) {
+      this.started = !0;
+      try {
+        const s = f(
+          this.serverUrl,
+          this.request,
+          this.abortController.signal,
+          this.token
+        );
+        for await (const t of s)
+          this.processEvent(t);
+        for (const t of this.handlers.done)
+          t(this.response);
+      } catch (s) {
+        if (!(s instanceof DOMException && s.name === "AbortError")) {
+          const t = s instanceof Error ? s.message : "Unknown error";
+          for (const e of this.handlers.error)
+            e({ message: t });
+        }
+      }
+    }
+  }
+  processEvent(s) {
+    switch (s.type) {
+      case "text_delta":
+        this.response.text += s.content;
+        for (const t of this.handlers.text)
+          t({ text: s.content });
+        break;
+      case "tool_call_start":
+        this.toolCallNames.set(s.tool_id, s.tool_name);
+        for (const t of this.handlers.tool_call)
+          t({ tool: s.tool_name, params: s.parameters, toolId: s.tool_id });
+        this.response.toolCalls.push({
+          toolId: s.tool_id,
+          toolName: s.tool_name,
+          parameters: s.parameters,
+          status: "running"
+        });
+        break;
+      case "tool_call_result": {
+        const t = this.toolCallNames.get(s.tool_id) ?? "";
+        for (const a of this.handlers.tool_result)
+          a({ tool: t, data: s.result, duration_ms: s.duration_ms, toolId: s.tool_id });
+        const e = this.response.toolCalls.find((a) => a.toolId === s.tool_id);
+        e && (e.status = s.status, e.result = s.result, e.duration_ms = s.duration_ms, e.error = s.error);
+        break;
+      }
+      case "skill_activated":
+        this.response.skillsUsed.push(s.skill);
+        for (const t of this.handlers.skill_activated)
+          t({ name: s.skill });
+        break;
+      case "kb_proposal": {
+        const t = {
+          scope: s.scope,
+          title: s.title,
+          reasoning: s.reasoning
+        };
+        this.response.kbProposals.push(t);
+        for (const e of this.handlers.kb_proposal)
+          e(t);
+        break;
+      }
+      case "ask_user":
+        for (const t of this.handlers.ask_user)
+          t({ askId: s.ask_id, questions: s.questions });
+        break;
+      case "widget":
+        for (const t of this.handlers.widget)
+          t({ widgetType: s.widget_type, data: s.data });
+        break;
+      case "error":
+        for (const t of this.handlers.error)
+          t({ message: s.message });
+        break;
+    }
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+let _ = 0;
+function m() {
+  return _++, `msg-${Date.now()}-${String(_)}`;
+}
+class $ extends y {
+  constructor(t) {
+    super();
+    n(this, "config");
+    n(this, "sessionId", null);
+    n(this, "_messages", []);
+    n(this, "_isConnected", !1);
+    n(this, "_isStreaming", !1);
+    n(this, "connectAttempt", 0);
+    n(this, "maxReconnectAttempts", 3);
+    n(this, "_eventBus");
+    this.config = t, this._eventBus = new S(), t.entityExtractors && this._eventBus.setExtractors(t.entityExtractors), this._eventBus.on("entity_referenced", (e) => {
+      this.emit("entity_referenced", e);
+    });
+  }
+  /** 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 e = t instanceof Error ? t : new Error(String(t));
+      throw this.emit("error", e), e;
+    }
+  }
+  /** 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 e = {
+      type: "user",
+      id: m(),
+      text: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(e), this.emit("message", e);
+    const a = {
+      type: "assistant_text",
+      id: m(),
+      text: "",
+      toolCalls: [],
+      confirmations: [],
+      skillActivations: [],
+      kbProposals: [],
+      widgets: [],
+      contentBlocks: [],
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(a), this.emit("message", a), this._isStreaming = !0, this.emit("streaming_start", void 0);
+    try {
+      return await this.streamInternal(t, a);
+    } catch (o) {
+      if (this.connectAttempt < this.maxReconnectAttempts)
+        return await this.reconnectAndRetry(t, a);
+      throw o;
+    } finally {
+      this._isStreaming = !1, this.emit("streaming_end", void 0);
+    }
+  }
+  /**
+   * Stream a message, returning a ChatStream handle for event-based consumption.
+   */
+  stream(t) {
+    const e = {
+      type: "user",
+      id: m(),
+      text: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this._messages.push(e), this.emit("message", e), this._isStreaming = !0, this.emit("streaming_start", void 0);
+    const a = new C(this.config.serverUrl, {
+      message: t,
+      session_id: this.sessionId ?? void 0,
+      role: this.config.user.role
+    }, this.config.token);
+    return a.on("done", (o) => {
+      const l = {
+        type: "assistant_text",
+        id: m(),
+        text: o.text,
+        toolCalls: o.toolCalls,
+        confirmations: [],
+        skillActivations: o.skillsUsed,
+        kbProposals: o.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);
+    }), a.on("error", (o) => {
+      this._isStreaming = !1, this.emit("streaming_end", void 0), this.emit("error", new Error(o.message));
+    }), a;
+  }
+  async streamInternal(t, e) {
+    const a = {
+      text: "",
+      toolCalls: [],
+      skillsUsed: [],
+      kbProposals: []
+    }, o = /* @__PURE__ */ new Map(), l = f(
+      this.config.serverUrl,
+      {
+        message: t,
+        session_id: this.sessionId ?? void 0,
+        role: this.config.user.role
+      },
+      void 0,
+      this.config.token
+    );
+    for await (const r of l)
+      switch (r.type) {
+        case "init":
+          this.sessionId = r.session_id;
+          break;
+        case "text_delta":
+          a.text += r.content, e.text += r.content;
+          break;
+        case "tool_call_start": {
+          const i = {
+            toolId: r.tool_id,
+            toolName: r.tool_name,
+            parameters: r.parameters,
+            status: "running"
+          };
+          a.toolCalls.push(i), e.toolCalls = [...e.toolCalls, i], o.set(r.tool_id, {
+            toolName: r.tool_name,
+            parameters: r.parameters
+          });
+          break;
+        }
+        case "tool_call_result": {
+          const i = a.toolCalls.find((d) => d.toolId === r.tool_id);
+          i && (i.status = r.status, i.result = r.result, i.duration_ms = r.duration_ms, i.error = r.error), e.toolCalls = e.toolCalls.map(
+            (d) => d.toolId === r.tool_id ? { ...d, status: r.status, result: r.result, duration_ms: r.duration_ms, error: r.error } : d
+          );
+          const c = o.get(r.tool_id);
+          o.delete(r.tool_id);
+          const u = {
+            type: "tool_executed",
+            toolName: (c == null ? void 0 : c.toolName) ?? "",
+            toolId: r.tool_id,
+            parameters: (c == null ? void 0 : c.parameters) ?? {},
+            status: r.status,
+            result: r.result,
+            duration_ms: r.duration_ms,
+            error: r.error,
+            timestamp: r.timestamp
+          };
+          this._eventBus.processEvent(u), this.emit("tool_executed", u);
+          break;
+        }
+        case "skill_activated": {
+          a.skillsUsed.push(r.skill), e.skillActivations = [...e.skillActivations, r.skill];
+          const i = {
+            type: "skill_activated",
+            skill: r.skill,
+            timestamp: r.timestamp
+          };
+          this._eventBus.processEvent(i), this.emit("skill_activated", i);
+          break;
+        }
+        case "kb_proposal": {
+          const i = {
+            scope: r.scope,
+            title: r.title,
+            reasoning: r.reasoning
+          };
+          a.kbProposals.push(i), e.kbProposals = [...e.kbProposals, i];
+          const c = {
+            type: "kb_proposal",
+            proposal: i,
+            timestamp: r.timestamp
+          };
+          this._eventBus.processEvent(c), this.emit("kb_proposal_received", c);
+          break;
+        }
+        case "widget": {
+          const i = {
+            type: "widget_rendered",
+            widgetType: r.widget_type,
+            data: r.data,
+            timestamp: r.timestamp
+          };
+          this._eventBus.processEvent(i), this.emit("widget_rendered", i);
+          break;
+        }
+        case "error":
+          throw new Error(r.message);
+      }
+    return a;
+  }
+  async reconnectAndRetry(t, e) {
+    this.connectAttempt++, this.emit("reconnecting", this.connectAttempt);
+    const a = 100 * Math.pow(2, this.connectAttempt - 1);
+    await new Promise((o) => setTimeout(o, a));
+    try {
+      return await this.connect(), await this.streamInternal(t, e);
+    } catch (o) {
+      if (this.connectAttempt < this.maxReconnectAttempts)
+        return this.reconnectAndRetry(t, e);
+      throw o;
     }
-    return await i.json();
   }
 }
 export {
-  $ as RuntimeClient,
-  l as parseSSELine,
-  g as streamSSE,
-  y as streamSSEGet
+  $ as ChatClient,
+  C as ChatStream,
+  x as RuntimeClient,
+  y as TypedEventEmitter,
+  A as createChatClient,
+  b as createSession,
+  T as getSessionHistory,
+  B as listSessions,
+  P as parseSSELine,
+  f as streamChat,
+  p as streamSSE,
+  w as streamSSEGet,
+  N as updateSession
 };
 //# sourceMappingURL=client.js.map