@usecrow/client 0.1.21 → 0.1.26

package/dist/index.js

@@ -1,33 +1,29 @@
-// src/identity.ts
-var IdentityManager = class {
+import { C as x } from "./browserUse-BbPG4pH1.js";
+class _ {
   constructor() {
     this.state = {
       token: null,
       metadata: {},
-      isVerified: false
-    };
-    this.listeners = /* @__PURE__ */ new Set();
+      isVerified: !1
+    }, this.listeners = /* @__PURE__ */ new Set();
   }
   /**
    * Identify the current user with a JWT token
    */
-  identify(options) {
-    const { token, ...metadata } = options;
+  identify(t) {
+    const { token: e, ...s } = t;
     this.state = {
-      token,
-      metadata,
-      isVerified: false
+      token: e,
+      metadata: s,
+      isVerified: !1
       // Will be set when server confirms
-    };
-    this.notify();
-    console.log("[Crow] User identified");
+    }, this.notify(), console.log("[Crow] User identified");
   }
   /**
    * Update verification status (called when server confirms)
    */
-  setVerified(isVerified) {
-    this.state = { ...this.state, isVerified };
-    this.notify();
+  setVerified(t) {
+    this.state = { ...this.state, isVerified: t }, this.notify();
   }
   /**
    * Reset user identity (call on logout)
@@ -36,10 +32,8 @@ var IdentityManager = class {
     this.state = {
       token: null,
       metadata: {},
-      isVerified: false
-    };
-    this.notify();
-    console.log("[Crow] User reset");
+      isVerified: !1
+    }, this.notify(), console.log("[Crow] User reset");
   }
   /**
    * Get current identity token
@@ -68,48 +62,37 @@ var IdentityManager = class {
   /**
    * Subscribe to identity changes
    */
-  subscribe(callback) {
-    this.listeners.add(callback);
-    return () => this.listeners.delete(callback);
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
   }
   notify() {
-    const state = this.getState();
-    for (const listener of this.listeners) {
-      listener(state);
-    }
+    const t = this.getState();
+    for (const e of this.listeners)
+      e(t);
   }
-};
-
-// src/tools.ts
-var ToolManager = class {
+}
+class k {
   constructor() {
     this.handlers = {};
   }
   /**
    * Register client-side tool handlers
    */
-  register(tools) {
-    for (const [name, handler] of Object.entries(tools)) {
-      if (typeof handler === "function") {
-        this.handlers[name] = handler;
-        console.log(`[Crow] Registered client tool: ${name}`);
-      } else {
-        console.warn(`[Crow] Skipping ${name}: handler is not a function`);
-      }
-    }
+  register(t) {
+    for (const [e, s] of Object.entries(t))
+      typeof s == "function" ? (this.handlers[e] = s, console.log(`[Crow] Registered client tool: ${e}`)) : console.warn(`[Crow] Skipping ${e}: handler is not a function`);
   }
   /**
    * Unregister a tool handler
    */
-  unregister(name) {
-    delete this.handlers[name];
-    console.log(`[Crow] Unregistered client tool: ${name}`);
+  unregister(t) {
+    delete this.handlers[t], console.log(`[Crow] Unregistered client tool: ${t}`);
   }
   /**
    * Check if a tool is registered
    */
-  has(name) {
-    return name in this.handlers;
+  has(t) {
+    return t in this.handlers;
   }
   /**
    * Get all registered tool names
@@ -120,45 +103,36 @@ var ToolManager = class {
   /**
    * Execute a client-side tool
    */
-  async execute(name, args) {
-    const handler = this.handlers[name];
-    if (!handler) {
-      console.warn(`[Crow] No handler registered for tool: ${name}`);
-      return {
+  async execute(t, e) {
+    const s = this.handlers[t];
+    if (!s)
+      return console.warn(`[Crow] No handler registered for tool: ${t}`), {
         status: "error",
-        error: `No handler registered for tool: ${name}`
+        error: `No handler registered for tool: ${t}`
       };
-    }
     try {
-      console.log(`[Crow] Executing client tool: ${name}`, args);
-      const result = await handler(args);
-      console.log(`[Crow] Tool ${name} completed:`, result);
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error(`[Crow] Tool ${name} failed:`, error);
-      return {
+      console.log(`[Crow] Executing client tool: ${t}`, e);
+      const r = await s(e);
+      return console.log(`[Crow] Tool ${t} completed:`, r), r;
+    } catch (r) {
+      const i = r instanceof Error ? r.message : String(r);
+      return console.error(`[Crow] Tool ${t} failed:`, r), {
         status: "error",
-        error: errorMessage
+        error: i
       };
     }
   }
-};
-
-// src/conversations.ts
-var STORAGE_KEY_PREFIX = "crow_conv_";
-var ConversationManager = class {
-  constructor(productId, apiUrl) {
-    this.currentId = null;
-    this.productId = productId;
-    this.apiUrl = apiUrl;
-    this.currentId = this.loadFromStorage();
+}
+const C = "crow_conv_";
+class b {
+  constructor(t, e) {
+    this.currentId = null, this.productId = t, this.apiUrl = e, this.currentId = this.loadFromStorage();
   }
   /**
    * Get localStorage key for this product
    */
   getStorageKey() {
-    return `${STORAGE_KEY_PREFIX}${this.productId}`;
+    return `${C}${this.productId}`;
   }
   /**
    * Load conversation ID from localStorage
@@ -173,9 +147,9 @@ var ConversationManager = class {
   /**
    * Save conversation ID to localStorage
    */
-  saveToStorage(id) {
+  saveToStorage(t) {
     try {
-      localStorage.setItem(this.getStorageKey(), id);
+      localStorage.setItem(this.getStorageKey(), t);
     } catch {
     }
   }
@@ -197,13 +171,8 @@ var ConversationManager = class {
   /**
    * Set current conversation ID
    */
-  setCurrentId(id) {
-    this.currentId = id;
-    if (id) {
-      this.saveToStorage(id);
-    } else {
-      this.clearStorage();
-    }
+  setCurrentId(t) {
+    this.currentId = t, t ? this.saveToStorage(t) : this.clearStorage();
   }
   /**
    * Check if there's a restored conversation
@@ -215,174 +184,160 @@ var ConversationManager = class {
    * Clear current conversation (start new)
    */
   clear() {
-    this.currentId = null;
-    this.clearStorage();
+    this.currentId = null, this.clearStorage();
   }
   /**
    * Fetch list of conversations for verified user
    */
-  async getConversations(identityToken) {
+  async getConversations(t) {
     try {
-      const response = await fetch(
-        `${this.apiUrl}/api/chat/conversations?product_id=${this.productId}&identity_token=${encodeURIComponent(identityToken)}`
+      const e = await fetch(
+        `${this.apiUrl}/api/chat/conversations?product_id=${this.productId}&identity_token=${encodeURIComponent(t)}`
       );
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status}`);
-      }
-      const data = await response.json();
-      return data.conversations || [];
-    } catch (error) {
-      console.error("[Crow] Failed to load conversations:", error);
-      return [];
+      if (!e.ok)
+        throw new Error(`HTTP error: ${e.status}`);
+      return (await e.json()).conversations || [];
+    } catch (e) {
+      return console.error("[Crow] Failed to load conversations:", e), [];
     }
   }
   /**
    * Load conversation history for verified user
    */
-  async loadHistory(conversationId, identityToken) {
+  async loadHistory(t, e) {
     try {
-      const response = await fetch(
-        `${this.apiUrl}/api/chat/conversations/${conversationId}/history?product_id=${this.productId}&identity_token=${encodeURIComponent(identityToken)}`
+      const s = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${t}/history?product_id=${this.productId}&identity_token=${encodeURIComponent(e)}`
       );
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status}`);
-      }
-      const data = await response.json();
-      return this.parseHistoryMessages(data.messages || []);
-    } catch (error) {
-      console.error("[Crow] Failed to load conversation history:", error);
-      return [];
+      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(conversationId) {
+  async loadAnonymousHistory(t) {
     try {
-      const response = await fetch(
-        `${this.apiUrl}/api/chat/conversations/${conversationId}/history/anonymous?product_id=${this.productId}`
+      const e = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${t}/history/anonymous?product_id=${this.productId}`
       );
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status}`);
-      }
-      const data = await response.json();
-      return this.parseHistoryMessages(data.messages || []);
-    } catch (error) {
-      console.error("[Crow] Failed to load anonymous conversation history:", error);
-      return [];
+      if (!e.ok)
+        throw new Error(`HTTP error: ${e.status}`);
+      const s = await e.json();
+      return this.parseHistoryMessages(s.messages || []);
+    } catch (e) {
+      return console.error("[Crow] Failed to load anonymous conversation history:", e), [];
     }
   }
   /**
    * Parse history messages from API format
    */
-  parseHistoryMessages(messages) {
-    return messages.filter((msg) => msg.role !== "tool" && !msg.content.startsWith("[Client Tool Result:")).map((msg, idx) => ({
-      id: `history-${idx}`,
-      content: this.parseContent(msg.content),
-      role: msg.role === "assistant" ? "assistant" : "user",
+  parseHistoryMessages(t) {
+    return t.filter((e) => e.role !== "tool" && !e.content.startsWith("[Client Tool Result:")).map((e, s) => ({
+      id: `history-${s}`,
+      content: this.parseContent(e.content),
+      role: e.role === "assistant" ? "assistant" : "user",
       timestamp: /* @__PURE__ */ new Date()
     }));
   }
   /**
    * Parse structured content (with thinking/text blocks) and extract just text
    */
-  parseContent(content) {
+  parseContent(t) {
     try {
-      const parsed = JSON.parse(content);
-      if (Array.isArray(parsed)) {
-        const textBlock = parsed.find(
-          (b) => b.type === "text"
+      const e = JSON.parse(t);
+      if (Array.isArray(e)) {
+        const s = e.find(
+          (r) => r.type === "text"
         );
-        return textBlock?.text || content;
+        return (s == null ? void 0 : s.text) || t;
       }
     } catch {
     }
-    if (content.includes("'type': 'text'")) {
-      const textBlockMatch = content.match(
+    if (t.includes("'type': 'text'")) {
+      const e = t.match(
         /\{'text':\s*'((?:[^'\\]|\\.)*)'\s*,\s*'type':\s*'text'/
       );
-      if (textBlockMatch) {
-        return textBlockMatch[1].replace(/\\n/g, "\n").replace(/\\'/g, "'");
-      }
+      if (e)
+        return e[1].replace(/\\n/g, `
+`).replace(/\\'/g, "'");
     }
-    return content;
+    return t;
   }
-};
-
-// src/streaming.ts
-function parseSSEData(data) {
-  if (data === "[DONE]") {
+}
+function v(n) {
+  if (n === "[DONE]")
     return { type: "done" };
-  }
   try {
-    const parsed = JSON.parse(data);
-    switch (parsed.type) {
+    const t = JSON.parse(n);
+    switch (t.type) {
       case "verification_status":
         return {
           type: "verification_status",
-          isVerified: parsed.is_verified === true
+          isVerified: t.is_verified === !0
         };
       case "conversation_id":
         return {
           type: "conversation_id",
-          conversationId: parsed.conversation_id
+          conversationId: t.conversation_id
         };
       case "thinking":
-        if (parsed.status === "complete") {
-          return { type: "thinking_complete" };
-        }
-        return null;
+        return t.status === "complete" ? { type: "thinking_complete" } : null;
       case "thinking_token":
         return {
           type: "thinking",
-          content: parsed.content || ""
+          content: t.content || ""
         };
       case "content":
         return {
           type: "content",
-          text: parsed.content || "",
+          text: t.content || "",
           accumulated: ""
           // Will be set by caller
         };
       case "citations":
         return {
           type: "citations",
-          citations: parsed.citations
+          citations: t.citations
         };
       case "error":
         return {
           type: "error",
-          message: parsed.message || "Unknown error"
+          message: t.message || "Unknown error"
         };
       case "tool_call_start":
         return {
           type: "tool_call_start",
-          toolName: parsed.tool_name,
-          arguments: parsed.arguments || {}
+          toolName: t.tool_name,
+          arguments: t.arguments || {}
         };
       case "tool_call_complete":
         return {
           type: "tool_call_complete",
-          toolName: parsed.tool_name,
-          success: parsed.success
+          toolName: t.tool_name,
+          success: t.success
         };
       case "client_tool_call":
         return {
           type: "client_tool_call",
-          toolName: parsed.tool_name,
-          arguments: parsed.arguments || {}
+          toolName: t.tool_name,
+          arguments: t.arguments || {}
         };
       case "workflow_started":
         return {
           type: "workflow_started",
-          name: parsed.name,
-          todos: parsed.todos
+          name: t.name,
+          todos: t.todos
         };
       case "todo_updated":
         return {
           type: "workflow_todo_updated",
-          todoId: parsed.id,
-          status: parsed.status
+          todoId: t.id,
+          status: t.status
         };
       case "workflow_ended":
         return { type: "workflow_ended" };
@@ -392,99 +347,65 @@ function parseSSEData(data) {
         return null;
     }
   } catch {
-    console.error("[Crow] Failed to parse SSE data:", data);
-    return null;
+    return console.error("[Crow] Failed to parse SSE data:", n), null;
   }
 }
-function* parseSSEChunk(chunk) {
-  const lines = chunk.split("\n");
-  for (const line of lines) {
-    if (line.startsWith("data: ")) {
-      yield line.slice(6).trim();
-    }
-  }
+function* I(n) {
+  const t = n.split(`
+`);
+  for (const e of t)
+    e.startsWith("data: ") && (yield e.slice(6).trim());
 }
-async function* streamResponse(response, signal) {
-  const reader = response.body?.getReader();
-  if (!reader) {
+async function* M(n, t) {
+  var i;
+  const e = (i = n.body) == null ? void 0 : i.getReader();
+  if (!e)
     throw new Error("Response body is not readable");
-  }
-  const decoder = new TextDecoder();
-  let accumulatedContent = "";
+  const s = new TextDecoder();
+  let r = "";
   try {
-    while (true) {
-      if (signal?.aborted) {
-        reader.cancel();
+    for (; ; ) {
+      if (t != null && t.aborted) {
+        e.cancel();
         return;
       }
-      const { done, value } = await reader.read();
-      if (done) break;
-      const chunk = decoder.decode(value);
-      for (const data of parseSSEChunk(chunk)) {
-        const event = parseSSEData(data);
-        if (event) {
-          if (event.type === "content") {
-            accumulatedContent += event.text;
-            yield { ...event, accumulated: accumulatedContent };
-          } else {
-            yield event;
-          }
-          if (event.type === "done") {
-            return;
-          }
-        }
+      const { done: l, value: d } = await e.read();
+      if (l) break;
+      const h = s.decode(d);
+      for (const u of I(h)) {
+        const c = v(u);
+        if (c && (c.type === "content" ? (r += c.text, yield { ...c, accumulated: r }) : yield c, c.type === "done"))
+          return;
       }
     }
   } finally {
-    reader.releaseLock();
+    e.releaseLock();
   }
 }
-
-// src/defaultTools.ts
-var DEFAULT_TOOLS = {
+const w = {
   /**
    * Refresh the current page in the user's browser
    */
   refreshPage: async () => {
     try {
-      window.location.reload();
-      return { status: "success", data: { message: "Page refresh initiated" } };
-    } catch (error) {
-      return { status: "error", error: String(error) };
-    }
-  }
-};
-var DEFAULT_TOOL_NAMES = Object.keys(DEFAULT_TOOLS);
-
-// src/CrowClient.ts
-var DEFAULT_API_URL = "https://api.usecrow.org";
-var DEFAULT_MODEL = "claude-sonnet-4-20250514";
-var CrowClient = class {
-  constructor(config) {
-    this.context = {};
-    this.abortController = null;
-    this.callbacks = {};
-    // Message state
-    this._messages = [];
-    this.messageListeners = /* @__PURE__ */ new Set();
-    // Loading state
-    this._isLoading = false;
-    this.loadingListeners = /* @__PURE__ */ new Set();
-    this.config = {
-      productId: config.productId,
-      apiUrl: config.apiUrl || DEFAULT_API_URL,
-      model: config.model || DEFAULT_MODEL
-    };
-    this.identity = new IdentityManager();
-    this.tools = new ToolManager();
-    this.conversations = new ConversationManager(
+      return window.location.reload(), { status: "success", data: { message: "Page refresh initiated" } };
+    } catch (n) {
+      return { status: "error", error: String(n) };
+    }
+  }
+}, S = Object.keys(w), T = "https://api.usecrow.org", $ = "claude-sonnet-4-20250514";
+class E {
+  constructor(t) {
+    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: t.productId,
+      apiUrl: t.apiUrl || T,
+      model: t.model || $
+    }, this.identity = new _(), this.tools = new k(), this.conversations = new b(
       this.config.productId,
       this.config.apiUrl
-    );
-    this.tools.register(DEFAULT_TOOLS);
-    console.log("[Crow] Default tools registered:", DEFAULT_TOOL_NAMES.join(", "));
-    this.identity.subscribe((state) => {
-      this.callbacks.onVerificationStatus?.(state.isVerified);
+    ), this.tools.register(w), console.log("[Crow] Default tools registered:", S.join(", ")), this.identity.subscribe((e) => {
+      var s, r;
+      (r = (s = this.callbacks).onVerificationStatus) == null || r.call(s, e.isVerified);
     });
   }
   // ============================================================================
@@ -508,8 +429,8 @@ var CrowClient = class {
   get model() {
     return this.config.model;
   }
-  set model(value) {
-    this.config.model = value;
+  set model(t) {
+    this.config.model = t;
   }
   // ============================================================================
   // Event Callbacks
@@ -517,8 +438,8 @@ var CrowClient = class {
   /**
    * Register event callbacks
    */
-  on(callbacks) {
-    this.callbacks = { ...this.callbacks, ...callbacks };
+  on(t) {
+    this.callbacks = { ...this.callbacks, ...t };
   }
   // ============================================================================
   // Identity
@@ -526,15 +447,14 @@ var CrowClient = class {
   /**
    * Identify the current user with a JWT token
    */
-  identify(options) {
-    this.identity.identify(options);
+  identify(t) {
+    this.identity.identify(t);
   }
   /**
    * Reset user identity (call on logout)
    */
   resetUser() {
-    this.identity.reset();
-    this.clearMessages();
+    this.identity.reset(), this.clearMessages();
   }
   /**
    * Check if user is identified
@@ -554,14 +474,14 @@ var CrowClient = class {
   /**
    * Register client-side tool handlers
    */
-  registerTools(tools) {
-    this.tools.register(tools);
+  registerTools(t) {
+    this.tools.register(t);
   }
   /**
    * Unregister a tool handler
    */
-  unregisterTool(name) {
-    this.tools.unregister(name);
+  unregisterTool(t) {
+    this.tools.unregister(t);
   }
   /**
    * Get list of registered tool names
@@ -575,8 +495,8 @@ var CrowClient = class {
   /**
    * Set context data to be sent with messages
    */
-  setContext(data) {
-    this.context = { ...this.context, ...data };
+  setContext(t) {
+    this.context = { ...this.context, ...t };
   }
   /**
    * Clear context data
@@ -602,58 +522,49 @@ var CrowClient = class {
   /**
    * Subscribe to message changes
    */
-  onMessages(callback) {
-    this.messageListeners.add(callback);
-    return () => this.messageListeners.delete(callback);
+  onMessages(t) {
+    return this.messageListeners.add(t), () => this.messageListeners.delete(t);
   }
   /**
    * Subscribe to loading state changes
    */
-  onLoading(callback) {
-    this.loadingListeners.add(callback);
-    return () => this.loadingListeners.delete(callback);
+  onLoading(t) {
+    return this.loadingListeners.add(t), () => this.loadingListeners.delete(t);
   }
   /**
    * Clear all messages and start new conversation
    */
   clearMessages() {
-    this._messages = [];
-    this.conversations.clear();
-    this.notifyMessages();
+    this._messages = [], this.conversations.clear(), this.notifyMessages();
   }
   /**
    * Load messages from history
    */
-  loadMessages(messages) {
-    this._messages = messages;
-    this.notifyMessages();
+  loadMessages(t) {
+    this._messages = t, this.notifyMessages();
   }
   notifyMessages() {
-    const messages = this.messages;
-    for (const listener of this.messageListeners) {
-      listener(messages);
-    }
+    const t = this.messages;
+    for (const e of this.messageListeners)
+      e(t);
   }
-  setLoading(isLoading) {
-    this._isLoading = isLoading;
-    for (const listener of this.loadingListeners) {
-      listener(isLoading);
-    }
+  setLoading(t) {
+    this._isLoading = t;
+    for (const e of this.loadingListeners)
+      e(t);
   }
-  addMessage(message) {
-    this._messages = [...this._messages, message];
-    this.notifyMessages();
-    this.callbacks.onMessage?.(message);
+  addMessage(t) {
+    var e, s;
+    this._messages = [...this._messages, t], this.notifyMessages(), (s = (e = this.callbacks).onMessage) == null || s.call(e, t);
   }
-  updateMessage(id, updates) {
+  updateMessage(t, e) {
+    var s, r;
     this._messages = this._messages.map(
-      (msg) => msg.id === id ? { ...msg, ...updates } : msg
-    );
-    this.notifyMessages();
-    this.callbacks.onMessageUpdate?.(id, updates);
+      (i) => i.id === t ? { ...i, ...e } : i
+    ), this.notifyMessages(), (r = (s = this.callbacks).onMessageUpdate) == null || r.call(s, t, e);
   }
-  generateMessageId(prefix) {
-    return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  generateMessageId(t) {
+    return `${t}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
   }
   // ============================================================================
   // Conversations
@@ -667,37 +578,29 @@ var CrowClient = class {
   /**
    * Set current conversation ID
    */
-  set conversationId(id) {
-    this.conversations.setCurrentId(id);
+  set conversationId(t) {
+    this.conversations.setCurrentId(t);
   }
   /**
    * Get list of conversations for verified user
    */
   async getConversations() {
-    const token = this.identity.getToken();
-    if (!token) {
-      console.warn("[Crow] Cannot get conversations: user not identified");
-      return [];
-    }
-    return this.conversations.getConversations(token);
+    const t = this.identity.getToken();
+    return t ? this.conversations.getConversations(t) : (console.warn("[Crow] Cannot get conversations: user not identified"), []);
   }
   /**
    * Load conversation history
    */
-  async loadHistory(conversationId) {
-    const token = this.identity.getToken();
-    if (token) {
-      return this.conversations.loadHistory(conversationId, token);
-    }
-    return this.conversations.loadAnonymousHistory(conversationId);
+  async loadHistory(t) {
+    const e = this.identity.getToken();
+    return e ? this.conversations.loadHistory(t, e) : this.conversations.loadAnonymousHistory(t);
   }
   /**
    * Switch to a different conversation
    */
-  async switchConversation(conversationId) {
-    const messages = await this.loadHistory(conversationId);
-    this.conversations.setCurrentId(conversationId);
-    this.loadMessages(messages);
+  async switchConversation(t) {
+    const e = await this.loadHistory(t);
+    this.conversations.setCurrentId(t), this.loadMessages(e);
   }
   // ============================================================================
   // Messaging
@@ -706,35 +609,32 @@ var CrowClient = class {
    * Send a message and receive streaming response
    * Returns an async generator of stream events
    */
-  async *sendMessage(content) {
-    if (!content.trim()) {
+  async *sendMessage(t) {
+    var l, d, h, u, c, g, f, p, y, m;
+    if (!t.trim())
       return;
-    }
-    const userMsgId = this.generateMessageId("user");
+    const e = this.generateMessageId("user");
     this.addMessage({
-      id: userMsgId,
-      content,
+      id: e,
+      content: t,
       role: "user",
       timestamp: /* @__PURE__ */ new Date()
     });
-    const botMsgId = this.generateMessageId("assistant");
+    const s = this.generateMessageId("assistant");
     this.addMessage({
-      id: botMsgId,
+      id: s,
       content: "",
       role: "assistant",
       timestamp: /* @__PURE__ */ new Date()
-    });
-    this.setLoading(true);
-    this.abortController = new AbortController();
-    let accumulatedContent = "";
-    let accumulatedThinking = "";
+    }), this.setLoading(!0), this.abortController = new AbortController();
+    let r = "", i = "";
     try {
-      const response = await fetch(`${this.config.apiUrl}/api/chat/message`, {
+      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: content,
+          message: t,
           conversation_id: this.conversations.getCurrentId(),
           identity_token: this.identity.getToken(),
           model: this.config.model,
@@ -742,99 +642,75 @@ var CrowClient = class {
         }),
         signal: this.abortController.signal
       });
-      if (!response.ok) {
-        throw new Error(`HTTP error: ${response.status}`);
-      }
-      for await (const event of streamResponse(response, this.abortController.signal)) {
-        switch (event.type) {
+      if (!a.ok)
+        throw new Error(`HTTP error: ${a.status}`);
+      for await (const o of M(a, this.abortController.signal)) {
+        switch (o.type) {
           case "content":
-            accumulatedContent = event.accumulated;
-            this.updateMessage(botMsgId, { content: accumulatedContent });
+            r = o.accumulated, this.updateMessage(s, { content: r });
             break;
           case "thinking":
-            accumulatedThinking += event.content;
-            this.updateMessage(botMsgId, { thinking: accumulatedThinking });
+            i += o.content, this.updateMessage(s, { thinking: i });
             break;
           case "thinking_complete":
-            this.updateMessage(botMsgId, { thinkingComplete: true });
+            this.updateMessage(s, { thinkingComplete: !0 });
             break;
           case "citations":
-            this.updateMessage(botMsgId, { citations: event.citations });
+            this.updateMessage(s, { citations: o.citations });
             break;
           case "verification_status":
-            this.identity.setVerified(event.isVerified);
+            this.identity.setVerified(o.isVerified);
             break;
           case "conversation_id":
-            this.conversations.setCurrentId(event.conversationId);
+            this.conversations.setCurrentId(o.conversationId);
             break;
           case "client_tool_call":
-            await this.tools.execute(event.toolName, event.arguments);
-            this.callbacks.onToolCall?.(event);
+            await this.tools.execute(o.toolName, o.arguments), (d = (l = this.callbacks).onToolCall) == null || d.call(l, o);
             break;
           case "tool_call_start":
           case "tool_call_complete":
-            this.callbacks.onToolCall?.(event);
+            (u = (h = this.callbacks).onToolCall) == null || u.call(h, o);
             break;
           case "workflow_started":
           case "workflow_todo_updated":
           case "workflow_ended":
           case "workflow_complete_prompt":
-            this.callbacks.onWorkflow?.(event);
+            (g = (c = this.callbacks).onWorkflow) == null || g.call(c, o);
             break;
           case "error":
-            this.updateMessage(botMsgId, { content: event.message });
-            this.callbacks.onError?.(new Error(event.message));
+            this.updateMessage(s, { content: o.message }), (p = (f = this.callbacks).onError) == null || p.call(f, new Error(o.message));
             break;
         }
-        yield event;
+        yield o;
       }
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        if (accumulatedContent) {
-          this.updateMessage(botMsgId, { content: accumulatedContent });
-        } else {
-          this._messages = this._messages.filter((msg) => msg.id !== botMsgId);
-          this.notifyMessages();
-        }
+    } catch (a) {
+      if (a instanceof Error && a.name === "AbortError") {
+        r ? this.updateMessage(s, { content: r }) : (this._messages = this._messages.filter((o) => o.id !== s), this.notifyMessages());
         return;
       }
-      console.error("[Crow] Error:", error);
-      this.updateMessage(botMsgId, {
+      console.error("[Crow] Error:", a), this.updateMessage(s, {
         content: "Sorry, I encountered an error. Please try again."
-      });
-      this.callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+      }), (m = (y = this.callbacks).onError) == null || m.call(y, a instanceof Error ? a : new Error(String(a)));
     } finally {
-      this.setLoading(false);
-      this.abortController = null;
+      this.setLoading(!1), this.abortController = null;
     }
   }
   /**
    * Send a message and wait for complete response (non-streaming)
    */
-  async send(content) {
-    let lastMessage = null;
-    for await (const event of this.sendMessage(content)) {
-      if (event.type === "done") {
+  async send(t) {
+    let e = null;
+    for await (const r of this.sendMessage(t))
+      if (r.type === "done")
         break;
-      }
-    }
-    const messages = this.messages;
-    if (messages.length > 0) {
-      lastMessage = messages[messages.length - 1];
-      if (lastMessage.role === "assistant") {
-        return lastMessage;
-      }
-    }
-    return null;
+    const s = this.messages;
+    return s.length > 0 && (e = s[s.length - 1], e.role === "assistant") ? e : null;
   }
   /**
    * Stop current generation
    */
   stop() {
-    if (this.abortController) {
-      this.abortController.abort();
-      this.setLoading(false);
-    }
+    this.abortController && (this.abortController.abort(), this.setLoading(!1));
   }
   // ============================================================================
   // Cleanup
@@ -843,254 +719,18 @@ var CrowClient = class {
    * Destroy the client and clean up resources
    */
   destroy() {
-    this.stop();
-    this.messageListeners.clear();
-    this.loadingListeners.clear();
-  }
-};
-var PageControllerModule = null;
-async function getPageController() {
-  if (!PageControllerModule) {
-    try {
-      PageControllerModule = await import('@page-agent/page-controller');
-    } catch (error) {
-      throw new Error(
-        'PageController not available. Either import from "@usecrow/client/browser" or install @page-agent/page-controller as a dependency.'
-      );
-    }
+    this.stop(), this.messageListeners.clear(), this.loadingListeners.clear();
   }
-  return PageControllerModule.PageController;
 }
-var CrowBrowserUse = class {
-  constructor(config) {
-    this.pageController = null;
-    this.sessionId = null;
-    this.maxSteps = 20;
-    this.config = config;
-  }
-  /**
-   * Initialize PageController with non-blocking pointer
-   */
-  async initPageController() {
-    if (this.pageController) {
-      return this.pageController;
-    }
-    try {
-      const PageController = await getPageController();
-      this.pageController = new PageController({
-        enableMask: true,
-        viewportExpansion: 500,
-        highlightLabelOpacity: 0,
-        // Hide numbered labels from users
-        highlightOpacity: 0
-        // Hide highlight boxes from users
-      });
-      await this.pageController.showMask();
-      const mask = this.pageController.mask;
-      if (mask?.wrapper) {
-        mask.wrapper.style.pointerEvents = "none";
-      }
-      console.log("[CrowBrowserUse] PageController initialized with non-blocking pointer");
-      return this.pageController;
-    } catch (error) {
-      console.error("[CrowBrowserUse] Failed to import @page-agent/page-controller:", error);
-      throw new Error(
-        "Failed to initialize browser automation. Make sure @page-agent/page-controller is installed."
-      );
-    }
-  }
-  /**
-   * Execute a browser automation task
-   */
-  async execute(task) {
-    console.log("[CrowBrowserUse] Starting task:", task);
-    try {
-      const controller = await this.initPageController();
-      const startResponse = await this.startSession(task);
-      this.sessionId = startResponse.session_id;
-      this.maxSteps = startResponse.max_steps;
-      console.log("[CrowBrowserUse] Session started:", this.sessionId);
-      let stepCount = 0;
-      let lastActionResult;
-      while (stepCount < this.maxSteps) {
-        stepCount++;
-        const browserState = await controller.getBrowserState();
-        const stepResponse = await this.processStep(browserState, lastActionResult);
-        if (stepResponse.done) {
-          console.log("[CrowBrowserUse] Task completed:", stepResponse.message);
-          await this.cleanup();
-          return {
-            status: stepResponse.success ? "success" : "error",
-            data: {
-              message: stepResponse.message,
-              steps: stepCount
-            },
-            error: stepResponse.success ? void 0 : stepResponse.message
-          };
-        }
-        if (stepResponse.error) {
-          console.error("[CrowBrowserUse] Error:", stepResponse.error);
-          await this.cleanup();
-          return {
-            status: "error",
-            error: stepResponse.error
-          };
-        }
-        if (stepResponse.action) {
-          lastActionResult = await this.executeAction(controller, stepResponse.action);
-          console.log(`[CrowBrowserUse] Step ${stepCount}:`, lastActionResult);
-        }
-        if (stepResponse.reflection) {
-          console.log("[CrowBrowserUse] Reflection:", stepResponse.reflection.next_goal);
-        }
-      }
-      await this.cleanup();
-      return {
-        status: "error",
-        error: `Task incomplete after ${this.maxSteps} steps`
-      };
-    } catch (error) {
-      console.error("[CrowBrowserUse] Error:", error);
-      await this.cleanup();
-      return {
-        status: "error",
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-  /**
-   * Start a browser-use session on the server
-   */
-  async startSession(task) {
-    const response = await fetch(`${this.config.apiUrl}/api/browser-use/start`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        product_id: this.config.productId,
-        task
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ detail: "Unknown error" }));
-      throw new Error(error.detail || `Failed to start session: ${response.status}`);
-    }
-    return response.json();
-  }
-  /**
-   * Process a step on the server
-   */
-  async processStep(browserState, actionResult) {
-    const response = await fetch(`${this.config.apiUrl}/api/browser-use/step`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        session_id: this.sessionId,
-        product_id: this.config.productId,
-        browser_state: browserState,
-        action_result: actionResult
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ detail: "Unknown error" }));
-      throw new Error(error.detail || `Failed to process step: ${response.status}`);
-    }
-    return response.json();
-  }
-  /**
-   * Execute an action using PageController
-   */
-  async executeAction(controller, action) {
-    const actionName = Object.keys(action)[0];
-    const actionParams = action[actionName];
-    try {
-      switch (actionName) {
-        case "click_element_by_index": {
-          const result = await controller.clickElement(actionParams.index);
-          return result.message;
-        }
-        case "input_text": {
-          const result = await controller.inputText(
-            actionParams.index,
-            actionParams.text
-          );
-          return result.message;
-        }
-        case "select_dropdown_option": {
-          const result = await controller.selectOption(
-            actionParams.index,
-            actionParams.text
-          );
-          return result.message;
-        }
-        case "scroll": {
-          const result = await controller.scroll({
-            down: actionParams.down,
-            numPages: actionParams.num_pages,
-            pixels: actionParams.pixels,
-            index: actionParams.index
-          });
-          return result.message;
-        }
-        case "scroll_horizontally": {
-          const result = await controller.scrollHorizontally({
-            right: actionParams.right,
-            pixels: actionParams.pixels,
-            index: actionParams.index
-          });
-          return result.message;
-        }
-        case "wait": {
-          const seconds = actionParams.seconds || 1;
-          await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
-          return `Waited ${seconds} seconds`;
-        }
-        case "done": {
-          return "Task completed";
-        }
-        default:
-          return `Unknown action: ${actionName}`;
-      }
-    } catch (error) {
-      return `Action failed: ${error instanceof Error ? error.message : String(error)}`;
-    }
-  }
-  /**
-   * Cleanup resources
-   */
-  async cleanup() {
-    if (this.pageController) {
-      try {
-        await this.pageController.hideMask();
-        await this.pageController.cleanUpHighlights();
-        this.pageController.dispose();
-      } catch (error) {
-        console.warn("[CrowBrowserUse] Cleanup error:", error);
-      }
-      this.pageController = null;
-    }
-    if (this.sessionId) {
-      try {
-        await fetch(`${this.config.apiUrl}/api/browser-use/end`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            session_id: this.sessionId,
-            product_id: this.config.productId
-          })
-        });
-      } catch (error) {
-      }
-      this.sessionId = null;
-    }
-  }
-  /**
-   * Stop the current task
-   */
-  async stop() {
-    await this.cleanup();
-  }
+export {
+  b as ConversationManager,
+  x as CrowBrowserUse,
+  E as CrowClient,
+  w as DEFAULT_TOOLS,
+  S as DEFAULT_TOOL_NAMES,
+  _ as IdentityManager,
+  k as ToolManager,
+  I as parseSSEChunk,
+  v as parseSSEData,
+  M as streamResponse
 };
-
-export { ConversationManager, CrowBrowserUse, CrowClient, DEFAULT_TOOLS, DEFAULT_TOOL_NAMES, IdentityManager, ToolManager, parseSSEChunk, parseSSEData, streamResponse };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map