@usecrow/client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,844 @@
+'use strict';
+
+// src/identity.ts
+var IdentityManager = class {
+  constructor() {
+    this.state = {
+      token: null,
+      metadata: {},
+      isVerified: false
+    };
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Identify the current user with a JWT token
+   */
+  identify(options) {
+    const { token, ...metadata } = options;
+    this.state = {
+      token,
+      metadata,
+      isVerified: false
+      // Will be set when server confirms
+    };
+    this.notify();
+    console.log("[Crow] User identified");
+  }
+  /**
+   * Update verification status (called when server confirms)
+   */
+  setVerified(isVerified) {
+    this.state = { ...this.state, isVerified };
+    this.notify();
+  }
+  /**
+   * Reset user identity (call on logout)
+   */
+  reset() {
+    this.state = {
+      token: null,
+      metadata: {},
+      isVerified: false
+    };
+    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(callback) {
+    this.listeners.add(callback);
+    return () => this.listeners.delete(callback);
+  }
+  notify() {
+    const state = this.getState();
+    for (const listener of this.listeners) {
+      listener(state);
+    }
+  }
+};
+
+// src/tools.ts
+var ToolManager = class {
+  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`);
+      }
+    }
+  }
+  /**
+   * Unregister a tool handler
+   */
+  unregister(name) {
+    delete this.handlers[name];
+    console.log(`[Crow] Unregistered client tool: ${name}`);
+  }
+  /**
+   * Check if a tool is registered
+   */
+  has(name) {
+    return name in this.handlers;
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Object.keys(this.handlers);
+  }
+  /**
+   * 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 {
+        status: "error",
+        error: `No handler registered for tool: ${name}`
+      };
+    }
+    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 {
+        status: "error",
+        error: errorMessage
+      };
+    }
+  }
+};
+
+// 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();
+  }
+  /**
+   * Get localStorage key for this product
+   */
+  getStorageKey() {
+    return `${STORAGE_KEY_PREFIX}${this.productId}`;
+  }
+  /**
+   * Load conversation ID from localStorage
+   */
+  loadFromStorage() {
+    try {
+      return localStorage.getItem(this.getStorageKey());
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Save conversation ID to localStorage
+   */
+  saveToStorage(id) {
+    try {
+      localStorage.setItem(this.getStorageKey(), id);
+    } catch {
+    }
+  }
+  /**
+   * Clear conversation ID from localStorage
+   */
+  clearStorage() {
+    try {
+      localStorage.removeItem(this.getStorageKey());
+    } catch {
+    }
+  }
+  /**
+   * Get current conversation ID
+   */
+  getCurrentId() {
+    return this.currentId;
+  }
+  /**
+   * Set current conversation ID
+   */
+  setCurrentId(id) {
+    this.currentId = id;
+    if (id) {
+      this.saveToStorage(id);
+    } else {
+      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(identityToken) {
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/api/chat/conversations?product_id=${this.productId}&identity_token=${encodeURIComponent(identityToken)}`
+      );
+      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 [];
+    }
+  }
+  /**
+   * Load conversation history for verified user
+   */
+  async loadHistory(conversationId, identityToken) {
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${conversationId}/history?product_id=${this.productId}&identity_token=${encodeURIComponent(identityToken)}`
+      );
+      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 [];
+    }
+  }
+  /**
+   * Load conversation history for anonymous user
+   */
+  async loadAnonymousHistory(conversationId) {
+    try {
+      const response = await fetch(
+        `${this.apiUrl}/api/chat/conversations/${conversationId}/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 [];
+    }
+  }
+  /**
+   * Parse history messages from API format
+   */
+  parseHistoryMessages(messages) {
+    return messages.map((msg, idx) => ({
+      id: `history-${idx}`,
+      content: this.parseContent(msg.content),
+      role: msg.role === "assistant" ? "assistant" : "user",
+      timestamp: /* @__PURE__ */ new Date()
+    }));
+  }
+  /**
+   * Parse structured content (with thinking/text blocks) and extract just text
+   */
+  parseContent(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (Array.isArray(parsed)) {
+        const textBlock = parsed.find(
+          (b) => b.type === "text"
+        );
+        return textBlock?.text || content;
+      }
+    } catch {
+    }
+    if (content.includes("'type': 'text'")) {
+      const textBlockMatch = content.match(
+        /\{'text':\s*'((?:[^'\\]|\\.)*)'\s*,\s*'type':\s*'text'/
+      );
+      if (textBlockMatch) {
+        return textBlockMatch[1].replace(/\\n/g, "\n").replace(/\\'/g, "'");
+      }
+    }
+    return content;
+  }
+};
+
+// src/streaming.ts
+function parseSSEData(data) {
+  if (data === "[DONE]") {
+    return { type: "done" };
+  }
+  try {
+    const parsed = JSON.parse(data);
+    switch (parsed.type) {
+      case "verification_status":
+        return {
+          type: "verification_status",
+          isVerified: parsed.is_verified === true
+        };
+      case "conversation_id":
+        return {
+          type: "conversation_id",
+          conversationId: parsed.conversation_id
+        };
+      case "thinking":
+        if (parsed.status === "complete") {
+          return { type: "thinking_complete" };
+        }
+        return null;
+      case "thinking_token":
+        return {
+          type: "thinking",
+          content: parsed.content || ""
+        };
+      case "content":
+        return {
+          type: "content",
+          text: parsed.content || "",
+          accumulated: ""
+          // Will be set by caller
+        };
+      case "citations":
+        return {
+          type: "citations",
+          citations: parsed.citations
+        };
+      case "error":
+        return {
+          type: "error",
+          message: parsed.message || "Unknown error"
+        };
+      case "tool_call_start":
+        return {
+          type: "tool_call_start",
+          toolName: parsed.tool_name,
+          arguments: parsed.arguments || {}
+        };
+      case "tool_call_complete":
+        return {
+          type: "tool_call_complete",
+          toolName: parsed.tool_name,
+          success: parsed.success
+        };
+      case "client_tool_call":
+        return {
+          type: "client_tool_call",
+          toolName: parsed.tool_name,
+          arguments: parsed.arguments || {}
+        };
+      case "workflow_started":
+        return {
+          type: "workflow_started",
+          name: parsed.name,
+          todos: parsed.todos
+        };
+      case "todo_updated":
+        return {
+          type: "workflow_todo_updated",
+          todoId: parsed.id,
+          status: parsed.status
+        };
+      case "workflow_ended":
+        return { type: "workflow_ended" };
+      case "workflow_complete_prompt":
+        return { type: "workflow_complete_prompt" };
+      default:
+        return null;
+    }
+  } catch {
+    console.error("[Crow] Failed to parse SSE data:", data);
+    return null;
+  }
+}
+function* parseSSEChunk(chunk) {
+  const lines = chunk.split("\n");
+  for (const line of lines) {
+    if (line.startsWith("data: ")) {
+      yield line.slice(6).trim();
+    }
+  }
+}
+async function* streamResponse(response, signal) {
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("Response body is not readable");
+  }
+  const decoder = new TextDecoder();
+  let accumulatedContent = "";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        reader.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;
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// 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(
+      this.config.productId,
+      this.config.apiUrl
+    );
+    this.identity.subscribe((state) => {
+      this.callbacks.onVerificationStatus?.(state.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(value) {
+    this.config.model = value;
+  }
+  // ============================================================================
+  // Event Callbacks
+  // ============================================================================
+  /**
+   * Register event callbacks
+   */
+  on(callbacks) {
+    this.callbacks = { ...this.callbacks, ...callbacks };
+  }
+  // ============================================================================
+  // Identity
+  // ============================================================================
+  /**
+   * Identify the current user with a JWT token
+   */
+  identify(options) {
+    this.identity.identify(options);
+  }
+  /**
+   * 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(tools) {
+    this.tools.register(tools);
+  }
+  /**
+   * Unregister a tool handler
+   */
+  unregisterTool(name) {
+    this.tools.unregister(name);
+  }
+  /**
+   * Get list of registered tool names
+   */
+  getRegisteredTools() {
+    return this.tools.getRegisteredTools();
+  }
+  // ============================================================================
+  // Context
+  // ============================================================================
+  /**
+   * Set context data to be sent with messages
+   */
+  setContext(data) {
+    this.context = { ...this.context, ...data };
+  }
+  /**
+   * 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(callback) {
+    this.messageListeners.add(callback);
+    return () => this.messageListeners.delete(callback);
+  }
+  /**
+   * Subscribe to loading state changes
+   */
+  onLoading(callback) {
+    this.loadingListeners.add(callback);
+    return () => this.loadingListeners.delete(callback);
+  }
+  /**
+   * Clear all messages and start new conversation
+   */
+  clearMessages() {
+    this._messages = [];
+    this.conversations.clear();
+    this.notifyMessages();
+  }
+  /**
+   * Load messages from history
+   */
+  loadMessages(messages) {
+    this._messages = messages;
+    this.notifyMessages();
+  }
+  notifyMessages() {
+    const messages = this.messages;
+    for (const listener of this.messageListeners) {
+      listener(messages);
+    }
+  }
+  setLoading(isLoading) {
+    this._isLoading = isLoading;
+    for (const listener of this.loadingListeners) {
+      listener(isLoading);
+    }
+  }
+  addMessage(message) {
+    this._messages = [...this._messages, message];
+    this.notifyMessages();
+    this.callbacks.onMessage?.(message);
+  }
+  updateMessage(id, updates) {
+    this._messages = this._messages.map(
+      (msg) => msg.id === id ? { ...msg, ...updates } : msg
+    );
+    this.notifyMessages();
+    this.callbacks.onMessageUpdate?.(id, updates);
+  }
+  generateMessageId(prefix) {
+    return `${prefix}-${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(id) {
+    this.conversations.setCurrentId(id);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Load conversation history
+   */
+  async loadHistory(conversationId) {
+    const token = this.identity.getToken();
+    if (token) {
+      return this.conversations.loadHistory(conversationId, token);
+    }
+    return this.conversations.loadAnonymousHistory(conversationId);
+  }
+  /**
+   * Switch to a different conversation
+   */
+  async switchConversation(conversationId) {
+    const messages = await this.loadHistory(conversationId);
+    this.conversations.setCurrentId(conversationId);
+    this.loadMessages(messages);
+  }
+  // ============================================================================
+  // Messaging
+  // ============================================================================
+  /**
+   * Send a message and receive streaming response
+   * Returns an async generator of stream events
+   */
+  async *sendMessage(content) {
+    if (!content.trim()) {
+      return;
+    }
+    const userMsgId = this.generateMessageId("user");
+    this.addMessage({
+      id: userMsgId,
+      content,
+      role: "user",
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    const botMsgId = this.generateMessageId("assistant");
+    this.addMessage({
+      id: botMsgId,
+      content: "",
+      role: "assistant",
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    this.setLoading(true);
+    this.abortController = new AbortController();
+    let accumulatedContent = "";
+    let accumulatedThinking = "";
+    try {
+      const response = 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,
+          conversation_id: this.conversations.getCurrentId(),
+          identity_token: this.identity.getToken(),
+          model: this.config.model,
+          context: Object.keys(this.context).length > 0 ? this.context : void 0
+        }),
+        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) {
+          case "content":
+            accumulatedContent = event.accumulated;
+            this.updateMessage(botMsgId, { content: accumulatedContent });
+            break;
+          case "thinking":
+            accumulatedThinking += event.content;
+            this.updateMessage(botMsgId, { thinking: accumulatedThinking });
+            break;
+          case "thinking_complete":
+            this.updateMessage(botMsgId, { thinkingComplete: true });
+            break;
+          case "citations":
+            this.updateMessage(botMsgId, { citations: event.citations });
+            break;
+          case "verification_status":
+            this.identity.setVerified(event.isVerified);
+            break;
+          case "conversation_id":
+            this.conversations.setCurrentId(event.conversationId);
+            break;
+          case "client_tool_call":
+            await this.tools.execute(event.toolName, event.arguments);
+            this.callbacks.onToolCall?.(event);
+            break;
+          case "tool_call_start":
+          case "tool_call_complete":
+            this.callbacks.onToolCall?.(event);
+            break;
+          case "workflow_started":
+          case "workflow_todo_updated":
+          case "workflow_ended":
+          case "workflow_complete_prompt":
+            this.callbacks.onWorkflow?.(event);
+            break;
+          case "error":
+            this.updateMessage(botMsgId, { content: event.message });
+            this.callbacks.onError?.(new Error(event.message));
+            break;
+        }
+        yield event;
+      }
+    } 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();
+        }
+        return;
+      }
+      console.error("[Crow] Error:", error);
+      this.updateMessage(botMsgId, {
+        content: "Sorry, I encountered an error. Please try again."
+      });
+      this.callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+    } finally {
+      this.setLoading(false);
+      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") {
+        break;
+      }
+    }
+    const messages = this.messages;
+    if (messages.length > 0) {
+      lastMessage = messages[messages.length - 1];
+      if (lastMessage.role === "assistant") {
+        return lastMessage;
+      }
+    }
+    return null;
+  }
+  /**
+   * Stop current generation
+   */
+  stop() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.setLoading(false);
+    }
+  }
+  // ============================================================================
+  // Cleanup
+  // ============================================================================
+  /**
+   * Destroy the client and clean up resources
+   */
+  destroy() {
+    this.stop();
+    this.messageListeners.clear();
+    this.loadingListeners.clear();
+  }
+};
+
+exports.ConversationManager = ConversationManager;
+exports.CrowClient = CrowClient;
+exports.IdentityManager = IdentityManager;
+exports.ToolManager = ToolManager;
+exports.parseSSEChunk = parseSSEChunk;
+exports.parseSSEData = parseSSEData;
+exports.streamResponse = streamResponse;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map