@usecrow/client 0.1.43 → 0.1.45

package/dist/index.native.js

@@ -0,0 +1,788 @@
+class I {
+  constructor() {
+    this.state = {
+      token: null,
+      metadata: {},
+      isVerified: !1
+    }, this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Identify the current user with a JWT token
+   */
+  identify(e) {
+    const { token: t, ...s } = e;
+    this.state = {
+      token: t,
+      metadata: s,
+      isVerified: !1
+      // Will be set when server confirms
+    }, this.notify(), console.log("[Crow] User identified");
+  }
+  /**
+   * Update verification status (called when server confirms)
+   */
+  setVerified(e) {
+    this.state = { ...this.state, isVerified: e }, this.notify();
+  }
+  /**
+   * Reset user identity (call on logout)
+   */
+  reset() {
+    this.state = {
+      token: null,
+      metadata: {},
+      isVerified: !1
+    }, this.notify(), console.log("[Crow] User reset");
+  }
+  /**
+   * Get current identity token
+   */
+  getToken() {
+    return this.state.token;
+  }
+  /**
+   * Get current identity state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Check if user is identified
+   */
+  isIdentified() {
+    return this.state.token !== null;
+  }
+  /**
+   * Check if user is verified
+   */
+  isVerified() {
+    return this.state.isVerified;
+  }
+  /**
+   * Subscribe to identity changes
+   */
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  notify() {
+    const e = this.getState();
+    for (const t of this.listeners)
+      t(e);
+  }
+}
+class C {
+  constructor() {
+    this.handlers = {};
+  }
+  /**
+   * Register client-side tool handlers
+   */
+  register(e) {
+    for (const [t, s] of Object.entries(e))
+      typeof s == "function" ? (this.handlers[t] = s, console.log(`[Crow] Registered client tool: ${t}`)) : console.warn(`[Crow] Skipping ${t}: handler is not a function`);
+  }
+  /**
+   * Unregister a tool handler
+   */
+  unregister(e) {
+    delete this.handlers[e], console.log(`[Crow] Unregistered client tool: ${e}`);
+  }
+  /**
+   * Check if a tool is registered
+   */
+  has(e) {
+    return e in this.handlers;
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Object.keys(this.handlers);
+  }
+  /**
+   * Execute a client-side tool
+   */
+  async execute(e, t) {
+    const s = this.handlers[e];
+    if (!s)
+      return console.warn(`[Crow] No handler registered for tool: ${e}`), {
+        status: "error",
+        error: `No handler registered for tool: ${e}`
+      };
+    try {
+      console.log(`[Crow] Executing client tool: ${e}`, t);
+      const r = await s(t);
+      return console.log(`[Crow] Tool ${e} completed:`, r), r;
+    } catch (r) {
+      const i = r instanceof Error ? r.message : String(r);
+      return console.error(`[Crow] Tool ${e} failed:`, r), {
+        status: "error",
+        error: i
+      };
+    }
+  }
+}
+const b = "crow_conv_";
+class S {
+  constructor(e, t, s) {
+    this.currentId = null, this.productId = e, this.apiUrl = t, this.storage = s, this.currentId = this.loadFromStorage();
+  }
+  /**
+   * Get storage key for this product
+   */
+  getStorageKey() {
+    return `${b}${this.productId}`;
+  }
+  /**
+   * Load conversation ID from storage
+   */
+  loadFromStorage() {
+    try {
+      return this.storage.getItem(this.getStorageKey());
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save conversation ID to storage
+   */
+  saveToStorage(e) {
+    try {
+      this.storage.setItem(this.getStorageKey(), e);
+    } catch {
+    }
+  }
+  /**
+   * Clear conversation ID from storage
+   */
+  clearStorage() {
+    try {
+      this.storage.removeItem(this.getStorageKey());
+    } catch {
+    }
+  }
+  /**
+   * Get current conversation ID
+   */
+  getCurrentId() {
+    return this.currentId;
+  }
+  /**
+   * Set current conversation ID
+   */
+  setCurrentId(e) {
+    this.currentId = e, e ? this.saveToStorage(e) : this.clearStorage();
+  }
+  /**
+   * Check if there's a restored conversation
+   */
+  hasRestoredConversation() {
+    return this.currentId !== null;
+  }
+  /**
+   * Clear current conversation (start new)
+   */
+  clear() {
+    this.currentId = null, this.clearStorage();
+  }
+  /**
+   * Fetch list of conversations for verified user
+   */
+  async getConversations(e) {
+    try {
+      const t = await fetch(
+        `${this.apiUrl}/api/chat/conversations?product_id=${this.productId}&identity_token=${encodeURIComponent(e)}`
+      );
+      if (!t.ok)
+        throw new Error(`HTTP error: ${t.status}`);
+      return (await t.json()).conversations || [];
+    } catch (t) {
+      return console.error("[Crow] Failed to load conversations:", t), [];
+    }
+  }
+  /**
+   * Load conversation history for verified user
+   */
+  async loadHistory(e, t) {
+    try {
+      const s = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${e}/history?product_id=${this.productId}&identity_token=${encodeURIComponent(t)}`
+      );
+      if (!s.ok)
+        throw new Error(`HTTP error: ${s.status}`);
+      const r = await s.json();
+      return this.parseHistoryMessages(r.messages || []);
+    } catch (s) {
+      return console.error("[Crow] Failed to load conversation history:", s), [];
+    }
+  }
+  /**
+   * Load conversation history for anonymous user
+   */
+  async loadAnonymousHistory(e) {
+    try {
+      const t = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${e}/history/anonymous?product_id=${this.productId}`
+      );
+      if (!t.ok)
+        throw new Error(`HTTP error: ${t.status}`);
+      const s = await t.json();
+      return this.parseHistoryMessages(s.messages || []);
+    } catch (t) {
+      return console.error("[Crow] Failed to load anonymous conversation history:", t), [];
+    }
+  }
+  /**
+   * Parse history messages from API format
+   */
+  parseHistoryMessages(e) {
+    return e.filter((t) => t.role !== "tool" && !t.content.startsWith("[Client Tool Result:")).map((t, s) => ({
+      id: `history-${s}`,
+      content: this.parseContent(t.content),
+      role: t.role === "assistant" ? "assistant" : "user",
+      timestamp: /* @__PURE__ */ new Date()
+    }));
+  }
+  /**
+   * Parse structured content (with thinking/text blocks) and extract just text
+   */
+  parseContent(e) {
+    try {
+      const t = JSON.parse(e);
+      if (Array.isArray(t)) {
+        const s = t.find(
+          (r) => r.type === "text"
+        );
+        return (s == null ? void 0 : s.text) || e;
+      }
+    } catch {
+    }
+    if (e.includes("'type': 'text'")) {
+      const t = e.match(
+        /\{'text':\s*'((?:[^'\\]|\\.)*)'\s*,\s*'type':\s*'text'/
+      );
+      if (t)
+        return t[1].replace(/\\n/g, `
+`).replace(/\\'/g, "'");
+    }
+    return e;
+  }
+}
+function M(o) {
+  if (o === "[DONE]")
+    return { type: "done" };
+  try {
+    const e = JSON.parse(o);
+    switch (e.type) {
+      case "verification_status":
+        return {
+          type: "verification_status",
+          isVerified: e.is_verified === !0
+        };
+      case "conversation_id":
+        return {
+          type: "conversation_id",
+          conversationId: e.conversation_id
+        };
+      case "thinking":
+        return e.status === "complete" ? { type: "thinking_complete" } : null;
+      case "thinking_token":
+        return {
+          type: "thinking",
+          content: e.content || ""
+        };
+      case "content":
+        return {
+          type: "content",
+          text: e.content || "",
+          accumulated: ""
+          // Will be set by caller
+        };
+      case "citations":
+        return {
+          type: "citations",
+          citations: e.citations
+        };
+      case "error":
+        return {
+          type: "error",
+          message: e.message || "Unknown error"
+        };
+      case "tool_call_start":
+        return {
+          type: "tool_call_start",
+          toolName: e.tool_name,
+          displayName: e.display_name || void 0,
+          arguments: e.arguments || {}
+        };
+      case "tool_call_complete":
+        return {
+          type: "tool_call_complete",
+          toolName: e.tool_name,
+          displayName: e.display_name || void 0,
+          success: e.success
+        };
+      case "client_tool_call":
+        return {
+          type: "client_tool_call",
+          toolName: e.tool_name,
+          displayName: e.display_name || void 0,
+          arguments: e.arguments || {}
+        };
+      case "tool_consent_required":
+        return {
+          type: "tool_consent_required",
+          toolName: e.tool_name,
+          displayName: e.display_name || void 0,
+          arguments: e.arguments || {}
+        };
+      case "workflow_started":
+        return {
+          type: "workflow_started",
+          name: e.name,
+          todos: e.todos
+        };
+      case "todo_updated":
+        return {
+          type: "workflow_todo_updated",
+          todoId: e.id,
+          status: e.status
+        };
+      case "workflow_ended":
+        return { type: "workflow_ended" };
+      case "workflow_complete_prompt":
+        return { type: "workflow_complete_prompt" };
+      default:
+        return null;
+    }
+  } catch {
+    return console.error("[Crow] Failed to parse SSE data:", o), null;
+  }
+}
+function* T(o) {
+  const e = o.split(`
+`);
+  for (const t of e)
+    t.startsWith("data: ") && (yield t.slice(6).trim());
+}
+async function* $(o, e) {
+  var i;
+  const t = (i = o.body) == null ? void 0 : i.getReader();
+  if (!t)
+    throw new Error("Response body is not readable");
+  const s = new TextDecoder();
+  let r = "";
+  try {
+    for (; ; ) {
+      if (e != null && e.aborted) {
+        t.cancel();
+        return;
+      }
+      const { done: l, value: d } = await t.read();
+      if (l) break;
+      const h = s.decode(d);
+      for (const u of T(h)) {
+        const c = M(u);
+        if (c && (c.type === "content" ? (r += c.text, yield { ...c, accumulated: r }) : yield c, c.type === "done"))
+          return;
+      }
+    }
+  } finally {
+    t.releaseLock();
+  }
+}
+const E = typeof window < "u" && typeof document < "u";
+async function L() {
+  var o;
+  try {
+    const e = document.title, t = window.location.href, s = window.location.pathname, r = (((o = document.body) == null ? void 0 : o.innerText) || "").slice(0, 2e3).trim();
+    return {
+      status: "success",
+      data: {
+        title: e,
+        url: t,
+        pathname: s,
+        visibleText: r
+      }
+    };
+  } catch (e) {
+    return {
+      status: "error",
+      error: e instanceof Error ? e.message : "Failed to read screen"
+    };
+  }
+}
+const _ = E ? { whatsOnScreen: L } : {}, w = Object.keys(_);
+function x() {
+  try {
+    const o = "__crow_test__";
+    return localStorage.setItem(o, "1"), localStorage.removeItem(o), {
+      getItem: (e) => localStorage.getItem(e),
+      setItem: (e, t) => localStorage.setItem(e, t),
+      removeItem: (e) => localStorage.removeItem(e)
+    };
+  } catch {
+    return k();
+  }
+}
+function k() {
+  const o = /* @__PURE__ */ new Map();
+  return {
+    getItem: (e) => o.get(e) ?? null,
+    setItem: (e, t) => o.set(e, t),
+    removeItem: (e) => o.delete(e)
+  };
+}
+const U = "https://api.usecrow.org", R = "claude-sonnet-4-20250514", v = typeof window < "u" && typeof document < "u";
+function N(o) {
+  return o.storage ? o.storage : v ? x() : k();
+}
+function O(o) {
+  return o.streamReader ? o.streamReader : $;
+}
+class A {
+  constructor(e) {
+    this.context = {}, this.abortController = null, this.callbacks = {}, this._messages = [], this.messageListeners = /* @__PURE__ */ new Set(), this._isLoading = !1, this.loadingListeners = /* @__PURE__ */ new Set(), this.config = {
+      productId: e.productId,
+      apiUrl: e.apiUrl || U,
+      model: e.model || R,
+      subdomain: e.subdomain
+    };
+    const t = N(e);
+    this.readStream = O(e), this.identity = new I(), this.tools = new C(), this.conversations = new S(
+      this.config.productId,
+      this.config.apiUrl,
+      t
+    ), (e.enableBrowserTools ?? (v && w.length > 0)) && (this.tools.register(_), console.log("[Crow] Default tools registered:", w.join(", "))), this.identity.subscribe((r) => {
+      var i, l;
+      (l = (i = this.callbacks).onVerificationStatus) == null || l.call(i, r.isVerified);
+    });
+  }
+  // ============================================================================
+  // Configuration
+  // ============================================================================
+  /**
+   * Get current product ID
+   */
+  get productId() {
+    return this.config.productId;
+  }
+  /**
+   * Get current API URL
+   */
+  get apiUrl() {
+    return this.config.apiUrl;
+  }
+  /**
+   * Get/set current model
+   */
+  get model() {
+    return this.config.model;
+  }
+  set model(e) {
+    this.config.model = e;
+  }
+  // ============================================================================
+  // Event Callbacks
+  // ============================================================================
+  /**
+   * Register event callbacks
+   */
+  on(e) {
+    this.callbacks = { ...this.callbacks, ...e };
+  }
+  // ============================================================================
+  // Identity
+  // ============================================================================
+  /**
+   * Identify the current user with a JWT token
+   */
+  identify(e) {
+    this.identity.identify(e);
+  }
+  /**
+   * Reset user identity (call on logout)
+   */
+  resetUser() {
+    this.identity.reset(), this.clearMessages();
+  }
+  /**
+   * Check if user is identified
+   */
+  isIdentified() {
+    return this.identity.isIdentified();
+  }
+  /**
+   * Check if user is verified by server
+   */
+  isVerified() {
+    return this.identity.isVerified();
+  }
+  // ============================================================================
+  // Tools
+  // ============================================================================
+  /**
+   * Register client-side tool handlers
+   */
+  registerTools(e) {
+    this.tools.register(e);
+  }
+  /**
+   * Unregister a tool handler
+   */
+  unregisterTool(e) {
+    this.tools.unregister(e);
+  }
+  /**
+   * Get list of registered tool names
+   */
+  getRegisteredTools() {
+    return this.tools.getRegisteredTools();
+  }
+  // ============================================================================
+  // Context
+  // ============================================================================
+  /**
+   * Set context data to be sent with messages
+   */
+  setContext(e) {
+    this.context = { ...this.context, ...e };
+  }
+  /**
+   * Clear context data
+   */
+  clearContext() {
+    this.context = {};
+  }
+  // ============================================================================
+  // Messages
+  // ============================================================================
+  /**
+   * Get current messages
+   */
+  get messages() {
+    return [...this._messages];
+  }
+  /**
+   * Check if currently loading/streaming
+   */
+  get isLoading() {
+    return this._isLoading;
+  }
+  /**
+   * Subscribe to message changes
+   */
+  onMessages(e) {
+    return this.messageListeners.add(e), () => this.messageListeners.delete(e);
+  }
+  /**
+   * Subscribe to loading state changes
+   */
+  onLoading(e) {
+    return this.loadingListeners.add(e), () => this.loadingListeners.delete(e);
+  }
+  /**
+   * Clear all messages and start new conversation
+   */
+  clearMessages() {
+    this._messages = [], this.conversations.clear(), this.notifyMessages();
+  }
+  /**
+   * Load messages from history
+   */
+  loadMessages(e) {
+    this._messages = e, this.notifyMessages();
+  }
+  notifyMessages() {
+    const e = this.messages;
+    for (const t of this.messageListeners)
+      t(e);
+  }
+  setLoading(e) {
+    this._isLoading = e;
+    for (const t of this.loadingListeners)
+      t(e);
+  }
+  addMessage(e) {
+    var t, s;
+    this._messages = [...this._messages, e], this.notifyMessages(), (s = (t = this.callbacks).onMessage) == null || s.call(t, e);
+  }
+  updateMessage(e, t) {
+    var s, r;
+    this._messages = this._messages.map(
+      (i) => i.id === e ? { ...i, ...t } : i
+    ), this.notifyMessages(), (r = (s = this.callbacks).onMessageUpdate) == null || r.call(s, e, t);
+  }
+  generateMessageId(e) {
+    return `${e}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  // ============================================================================
+  // Conversations
+  // ============================================================================
+  /**
+   * Get current conversation ID
+   */
+  get conversationId() {
+    return this.conversations.getCurrentId();
+  }
+  /**
+   * Set current conversation ID
+   */
+  set conversationId(e) {
+    this.conversations.setCurrentId(e);
+  }
+  /**
+   * Get list of conversations for verified user
+   */
+  async getConversations() {
+    const e = this.identity.getToken();
+    return e ? this.conversations.getConversations(e) : (console.warn("[Crow] Cannot get conversations: user not identified"), []);
+  }
+  /**
+   * Load conversation history
+   */
+  async loadHistory(e) {
+    const t = this.identity.getToken();
+    return t ? this.conversations.loadHistory(e, t) : this.conversations.loadAnonymousHistory(e);
+  }
+  /**
+   * Switch to a different conversation
+   */
+  async switchConversation(e) {
+    const t = await this.loadHistory(e);
+    this.conversations.setCurrentId(e), this.loadMessages(t);
+  }
+  // ============================================================================
+  // Messaging
+  // ============================================================================
+  /**
+   * Send a message and receive streaming response
+   * Returns an async generator of stream events
+   */
+  async *sendMessage(e) {
+    var l, d, h, u, c, g, f, m, p, y;
+    if (!e.trim())
+      return;
+    const t = this.generateMessageId("user");
+    this.addMessage({
+      id: t,
+      content: e,
+      role: "user",
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    const s = this.generateMessageId("assistant");
+    this.addMessage({
+      id: s,
+      content: "",
+      role: "assistant",
+      timestamp: /* @__PURE__ */ new Date()
+    }), this.setLoading(!0), this.abortController = new AbortController();
+    let r = "", i = "";
+    try {
+      const a = await fetch(`${this.config.apiUrl}/api/chat/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          product_id: this.config.productId,
+          message: e,
+          conversation_id: this.conversations.getCurrentId(),
+          identity_token: this.identity.getToken(),
+          model: this.config.model,
+          subdomain: this.config.subdomain,
+          context: Object.keys(this.context).length > 0 ? this.context : void 0
+        }),
+        signal: this.abortController.signal
+      });
+      if (!a.ok)
+        throw new Error(`HTTP error: ${a.status}`);
+      for await (const n of this.readStream(a, this.abortController.signal)) {
+        switch (n.type) {
+          case "content":
+            r = n.accumulated, this.updateMessage(s, { content: r });
+            break;
+          case "thinking":
+            i += n.content, this.updateMessage(s, { thinking: i });
+            break;
+          case "thinking_complete":
+            this.updateMessage(s, { thinkingComplete: !0 });
+            break;
+          case "citations":
+            this.updateMessage(s, { citations: n.citations });
+            break;
+          case "verification_status":
+            this.identity.setVerified(n.isVerified);
+            break;
+          case "conversation_id":
+            this.conversations.setCurrentId(n.conversationId);
+            break;
+          case "client_tool_call":
+            await this.tools.execute(n.toolName, n.arguments), (d = (l = this.callbacks).onToolCall) == null || d.call(l, n);
+            break;
+          case "tool_call_start":
+          case "tool_call_complete":
+            (u = (h = this.callbacks).onToolCall) == null || u.call(h, n);
+            break;
+          case "workflow_started":
+          case "workflow_todo_updated":
+          case "workflow_ended":
+          case "workflow_complete_prompt":
+            (g = (c = this.callbacks).onWorkflow) == null || g.call(c, n);
+            break;
+          case "error":
+            this.updateMessage(s, { content: n.message }), (m = (f = this.callbacks).onError) == null || m.call(f, new Error(n.message));
+            break;
+        }
+        yield n;
+      }
+    } catch (a) {
+      if (a instanceof Error && a.name === "AbortError") {
+        r ? this.updateMessage(s, { content: r }) : (this._messages = this._messages.filter((n) => n.id !== s), this.notifyMessages());
+        return;
+      }
+      console.error("[Crow] Error:", a), this.updateMessage(s, {
+        content: "Sorry, I encountered an error. Please try again."
+      }), (y = (p = this.callbacks).onError) == null || y.call(p, a instanceof Error ? a : new Error(String(a)));
+    } finally {
+      this.setLoading(!1), this.abortController = null;
+    }
+  }
+  /**
+   * Send a message and wait for complete response (non-streaming)
+   */
+  async send(e) {
+    let t = null;
+    for await (const r of this.sendMessage(e))
+      if (r.type === "done")
+        break;
+    const s = this.messages;
+    return s.length > 0 && (t = s[s.length - 1], t.role === "assistant") ? t : null;
+  }
+  /**
+   * Stop current generation
+   */
+  stop() {
+    this.abortController && (this.abortController.abort(), this.setLoading(!1));
+  }
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
+  /**
+   * Destroy the client and clean up resources
+   */
+  destroy() {
+    this.stop(), this.messageListeners.clear(), this.loadingListeners.clear();
+  }
+}
+export {
+  S as ConversationManager,
+  A as CrowClient,
+  _ as DEFAULT_TOOLS,
+  w as DEFAULT_TOOL_NAMES,
+  I as IdentityManager,
+  C as ToolManager,
+  x as createLocalStorageAdapter,
+  k as createMemoryStorageAdapter,
+  T as parseSSEChunk,
+  M as parseSSEData,
+  $ as streamResponse
+};