@cilow/sdk 0.2.0 → 0.2.1

package/dist/react/hooks.js

@@ -0,0 +1,1183 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/hooks.tsx
+
+// src/client.ts
+async function fetchWithRetry(url, options, config) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  let lastError = null;
+  for (let attempt = 0; attempt <= config.retries; attempt++) {
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.text();
+        let apiError;
+        try {
+          apiError = JSON.parse(errorBody);
+        } catch {
+          apiError = {
+            code: `HTTP_${response.status}`,
+            message: errorBody || response.statusText
+          };
+        }
+        throw new CilowApiError(apiError.message, apiError.code, response.status, apiError.details);
+      }
+      return response;
+    } catch (error) {
+      lastError = error;
+      if (error instanceof CilowApiError) {
+        throw error;
+      }
+      if (config.debug) {
+        console.warn(`Cilow API request failed (attempt ${attempt + 1}/${config.retries + 1}):`, error);
+      }
+      if (attempt < config.retries) {
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 100));
+      }
+    }
+  }
+  clearTimeout(timeoutId);
+  throw lastError || new Error("Request failed");
+}
+var CilowApiError = class extends Error {
+  constructor(message, code, statusCode, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "CilowApiError";
+  }
+};
+var CilowClient = class {
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/$/, "");
+    this.apiKey = config.apiKey;
+    this.timeout = config.timeout ?? 3e4;
+    this.retries = config.retries ?? 3;
+    this.debug = config.debug ?? false;
+    const authHeaders = this.apiKey.startsWith("cilow_") ? { "X-API-Key": this.apiKey } : { Authorization: `Bearer ${this.apiKey}` };
+    this.headers = {
+      "Content-Type": "application/json",
+      ...authHeaders,
+      ...config.headers
+    };
+  }
+  /**
+   * Make an API request
+   */
+  async request(method, path, body, queryParams) {
+    let url = `${this.baseUrl}${path}`;
+    if (queryParams) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== void 0) {
+          params.append(key, String(value));
+        }
+      }
+      const queryString = params.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    if (this.debug) {
+      console.log(`Cilow API: ${method} ${url}`);
+    }
+    const response = await fetchWithRetry(
+      url,
+      {
+        method,
+        headers: this.headers,
+        body: body ? JSON.stringify(body) : void 0
+      },
+      { timeout: this.timeout, retries: this.retries, debug: this.debug }
+    );
+    const text = await response.text();
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  // ===========================================================================
+  // Simple API (remember, recall, forget)
+  // ===========================================================================
+  /**
+   * Store a memory (simple API)
+   *
+   * @param content - The content to remember
+   * @param options - Optional configuration
+   * @returns The created memory ID
+   *
+   * @example
+   * ```typescript
+   * await cilow.remember("User prefers dark mode", {
+   *   tags: ["preference"],
+   *   userId: "user-123"
+   * });
+   * ```
+   */
+  async remember(content, options) {
+    const response = await this.request("POST", "/api/v1/memory/add", {
+      content,
+      tags: options?.tags ?? [],
+      user_id: options?.userId,
+      session_id: options?.sessionId,
+      metadata: options?.metadata,
+      type: options?.tier
+    });
+    return response.memory_id || response.id || "";
+  }
+  /**
+   * Search memories (simple API)
+   *
+   * @param query - Search query text
+   * @param options - Search options
+   * @returns Array of search results
+   *
+   * @example
+   * ```typescript
+   * const memories = await cilow.recall("user preferences", {
+   *   limit: 10,
+   *   tags: ["preference"]
+   * });
+   * ```
+   */
+  async recall(query, options) {
+    const response = await this.request("POST", "/api/v1/memory/search", {
+      query,
+      limit: options?.limit ?? 10,
+      min_score: options?.minRelevance ?? 0.3,
+      tags: options?.tags,
+      user_id: options?.userId
+    });
+    return (response.results ?? []).map((r) => ({
+      memory: {
+        id: r.memory_id,
+        content: r.content,
+        tags: r.tags ?? [],
+        tier: "hot",
+        status: "active",
+        accessCount: 0,
+        tokenCount: Math.ceil(r.content.length / 4),
+        metadata: {},
+        createdAt: r.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        updatedAt: r.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+        lastAccessedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      score: r.similarity,
+      highlights: []
+    }));
+  }
+  /**
+   * Delete memories (simple API)
+   *
+   * @param filter - Filter criteria for deletion
+   * @returns Number of memories deleted
+   *
+   * @example
+   * ```typescript
+   * // Delete by tags
+   * await cilow.forget({ tags: ["temporary"] });
+   *
+   * // Delete by user
+   * await cilow.forget({ userId: "user-123" });
+   *
+   * // Delete specific memory
+   * await cilow.forget({ memoryId: "mem-abc" });
+   * ```
+   */
+  async forget(filter) {
+    if (filter.memoryId) {
+      await this.deleteMemory(filter.memoryId);
+      return 1;
+    }
+    const response = await this.request("DELETE", "/api/v1/memories/bulk", {
+      filter_tags: filter.tags,
+      user_id: filter.userId,
+      session_id: filter.sessionId,
+      older_than: filter.olderThan
+    });
+    return response.deleted ?? 0;
+  }
+  // ===========================================================================
+  // Memory CRUD Operations
+  // ===========================================================================
+  /**
+   * Create a new memory
+   */
+  async createMemory(content, options) {
+    return this.request("POST", "/api/v1/memories", {
+      content,
+      tags: options?.tags ?? [],
+      user_id: options?.userId,
+      session_id: options?.sessionId,
+      metadata: options?.metadata,
+      tier: options?.tier
+    });
+  }
+  /**
+   * Get a memory by ID
+   */
+  async getMemory(memoryId) {
+    return this.request("GET", `/api/v1/memories/${memoryId}`);
+  }
+  /**
+   * Update a memory
+   */
+  async updateMemory(memoryId, updates) {
+    return this.request("PATCH", `/api/v1/memories/${memoryId}`, {
+      content: updates.content,
+      tags: updates.tags,
+      metadata: updates.metadata,
+      tier: updates.tier
+    });
+  }
+  /**
+   * Delete a memory
+   */
+  async deleteMemory(memoryId) {
+    await this.request("DELETE", `/api/v1/memories/${memoryId}`);
+  }
+  /**
+   * List memories with pagination
+   */
+  async listMemories(options) {
+    const response = await this.request(
+      "GET",
+      "/api/v1/memory/list",
+      void 0,
+      {
+        limit: options?.limit ?? 20,
+        offset: options?.offset ?? 0,
+        user_id: options?.userId,
+        session_id: options?.sessionId,
+        tags: options?.tags?.join(","),
+        type: options?.tier
+      }
+    );
+    const items = (response.memories ?? []).map((m) => ({
+      id: m.memory_id || m.id || "",
+      content: m.content,
+      tags: m.tags ?? [],
+      createdAt: m.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      tier: m.type || "hot"
+    }));
+    const limit = options?.limit ?? 20;
+    const offset = options?.offset ?? 0;
+    const total = response.total ?? items.length;
+    return {
+      items,
+      total,
+      limit,
+      offset,
+      hasMore: offset + items.length < total
+    };
+  }
+  // ===========================================================================
+  // Search Operations
+  // ===========================================================================
+  /**
+   * Search memories with full options
+   */
+  async searchMemories(query) {
+    const response = await this.request("POST", "/api/v1/memories/search", {
+      text: query.text,
+      limit: query.limit ?? 10,
+      min_relevance: query.minRelevance ?? 0.3,
+      filter_tags: query.tags,
+      user_id: query.userId,
+      session_id: query.sessionId,
+      tier: query.tier,
+      created_after: query.createdAfter,
+      created_before: query.createdBefore,
+      include_archived: query.includeArchived,
+      mode: query.mode ?? "hybrid"
+    });
+    return response.results ?? [];
+  }
+  /**
+   * Advanced search with reranking and boosts
+   */
+  async advancedSearch(query) {
+    const response = await this.request("POST", "/api/v1/memories/search/advanced", {
+      text: query.text,
+      limit: query.limit ?? 10,
+      min_relevance: query.minRelevance ?? 0.3,
+      filter_tags: query.tags,
+      required_tags: query.requiredTags,
+      excluded_tags: query.excludedTags,
+      user_id: query.userId,
+      session_id: query.sessionId,
+      recency_boost: query.recencyBoost,
+      frequency_boost: query.frequencyBoost,
+      metadata_filters: query.metadataFilters,
+      reranker: query.reranker
+    });
+    return response.results ?? [];
+  }
+  /**
+   * Get context for AI applications
+   */
+  async getContext(query, options) {
+    const maxTokens = options?.maxTokens ?? 4e3;
+    const tokensPerChar = 0.25;
+    const results = await this.searchMemories({
+      text: query,
+      limit: 30,
+      minRelevance: 0.3,
+      userId: options?.userId,
+      tags: options?.tags
+    });
+    let context = "";
+    let estimatedTokens = 0;
+    const memoryIds = [];
+    const scores = [];
+    for (const result of results) {
+      const memoryText = `[Relevance: ${(result.score * 100).toFixed(0)}%]
+${result.memory.content}
+
+`;
+      const memoryTokens = Math.ceil(memoryText.length * tokensPerChar);
+      if (estimatedTokens + memoryTokens > maxTokens) break;
+      context += memoryText;
+      estimatedTokens += memoryTokens;
+      memoryIds.push(result.memory.id);
+      scores.push(result.score);
+    }
+    return {
+      context: context.trim(),
+      memoriesUsed: memoryIds.length,
+      estimatedTokens,
+      memoryIds,
+      scores
+    };
+  }
+  // ===========================================================================
+  // Conversation Operations
+  // ===========================================================================
+  /**
+   * Store a conversation turn
+   */
+  async storeConversation(turn) {
+    const content = `User: ${turn.userMessage}
+
+Assistant: ${turn.assistantResponse}`;
+    const tags = ["conversation"];
+    if (turn.sessionId) {
+      tags.push(`session:${turn.sessionId}`);
+    }
+    return this.remember(content, {
+      tags,
+      userId: turn.userId,
+      sessionId: turn.sessionId,
+      metadata: {
+        type: "conversation",
+        ...turn.metadata
+      }
+    });
+  }
+  /**
+   * Get conversation history for a session
+   */
+  async getConversationHistory(sessionId, options) {
+    const response = await this.listMemories({
+      sessionId,
+      tags: ["conversation"],
+      limit: options?.limit ?? 50,
+      offset: options?.offset ?? 0
+    });
+    return response.items;
+  }
+  // ===========================================================================
+  // Graph Operations
+  // ===========================================================================
+  /**
+   * Get a graph node
+   */
+  async getGraphNode(nodeId) {
+    return this.request("GET", `/api/v1/graph/nodes/${nodeId}`);
+  }
+  /**
+   * Create a graph node
+   */
+  async createGraphNode(type, name, properties) {
+    return this.request("POST", "/api/v1/graph/nodes", {
+      type,
+      name,
+      properties: properties ?? {}
+    });
+  }
+  /**
+   * Create a graph edge
+   */
+  async createGraphEdge(sourceId, targetId, type, properties) {
+    return this.request("POST", "/api/v1/graph/edges", {
+      source_id: sourceId,
+      target_id: targetId,
+      type,
+      properties: properties ?? {}
+    });
+  }
+  /**
+   * Traverse the graph from a starting node
+   */
+  async traverseGraph(options) {
+    return this.request("POST", "/api/v1/graph/traverse", {
+      start_node_id: options.startNodeId,
+      max_depth: options.maxDepth ?? 3,
+      relationship_types: options.relationshipTypes,
+      limit: options.limit ?? 100,
+      direction: options.direction ?? "both"
+    });
+  }
+  /**
+   * Get related nodes for a memory
+   */
+  async getRelatedNodes(memoryId) {
+    const response = await this.request(
+      "GET",
+      `/api/v1/memories/${memoryId}/related-nodes`
+    );
+    return response.nodes ?? [];
+  }
+  // ===========================================================================
+  // Statistics & Admin
+  // ===========================================================================
+  /**
+   * Get memory statistics
+   */
+  async getStats() {
+    return this.request("GET", "/api/v1/stats");
+  }
+  /**
+   * Get all tags with counts
+   */
+  async getTags() {
+    const response = await this.request("GET", "/api/v1/tags");
+    return response.tags ?? [];
+  }
+  /**
+   * Get user statistics
+   */
+  async getUserStats(userId) {
+    return this.request("GET", `/api/v1/users/${userId}/stats`);
+  }
+  /**
+   * Health check
+   */
+  async healthCheck() {
+    return this.request("GET", "/health");
+  }
+  // ===========================================================================
+  // Batch Operations
+  // ===========================================================================
+  /**
+   * Batch create memories
+   */
+  async batchCreate(items) {
+    const response = await this.request("POST", "/api/v1/memories/batch", {
+      memories: items.map((item) => ({
+        content: item.content,
+        tags: item.options?.tags ?? [],
+        user_id: item.options?.userId,
+        session_id: item.options?.sessionId,
+        metadata: item.options?.metadata
+      }))
+    });
+    return response.ids ?? [];
+  }
+  /**
+   * Batch delete memories
+   */
+  async batchDelete(memoryIds) {
+    const response = await this.request("DELETE", "/api/v1/memories/batch", {
+      ids: memoryIds
+    });
+    return response.deleted ?? 0;
+  }
+};
+
+// src/websocket.ts
+var CilowWebSocket = class {
+  constructor(config) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.reconnectCount = 0;
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+    this.messageQueue = [];
+    this.subscriptions = [];
+    this.listeners = /* @__PURE__ */ new Map();
+    this.allListeners = /* @__PURE__ */ new Set();
+    const httpUrl = config.apiUrl.replace(/\/$/, "");
+    this.wsUrl = config.wsUrl ?? httpUrl.replace(/^http/, "ws") + "/ws";
+    this.apiKey = config.apiKey;
+    this.reconnectAttempts = config.reconnectAttempts ?? 5;
+    this.reconnectDelay = config.reconnectDelay ?? 1e3;
+    this.heartbeatInterval = config.heartbeatInterval ?? 3e4;
+    this.messageQueueSize = config.messageQueueSize ?? 100;
+  }
+  /**
+   * Get current connection state
+   */
+  get connectionState() {
+    return this.state;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.state === "connected";
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.state = "connecting";
+    this.emitStatusEvent("connecting");
+    return new Promise((resolve, reject) => {
+      try {
+        const url = new URL(this.wsUrl);
+        url.searchParams.set("token", this.apiKey);
+        this.ws = new WebSocket(url.toString());
+        this.ws.onopen = () => {
+          this.state = "connected";
+          this.reconnectCount = 0;
+          this.emitStatusEvent("connected");
+          this.startHeartbeat();
+          this.flushMessageQueue();
+          this.resubscribe();
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          this.handleClose(event);
+        };
+        this.ws.onerror = (error) => {
+          if (this.state === "connecting") {
+            reject(new Error("WebSocket connection failed"));
+          }
+          this.handleError(error);
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event);
+        };
+      } catch (error) {
+        this.state = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.stopHeartbeat();
+    this.clearReconnectTimer();
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = "disconnected";
+    this.emitStatusEvent("disconnected", "Client initiated disconnect");
+  }
+  /**
+   * Subscribe to events with optional filter
+   */
+  subscribe(filter) {
+    if (filter) {
+      this.subscriptions.push(filter);
+    }
+    if (this.isConnected) {
+      this.sendSubscription(filter);
+    }
+  }
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(filter) {
+    if (filter) {
+      this.subscriptions = this.subscriptions.filter(
+        (s) => s.userId !== filter.userId || s.sessionId !== filter.sessionId || JSON.stringify(s.tags) !== JSON.stringify(filter.tags)
+      );
+    } else {
+      this.subscriptions = [];
+    }
+    if (this.isConnected) {
+      this.send({
+        type: "unsubscribe",
+        filter
+      });
+    }
+  }
+  /**
+   * Add event listener for specific event type
+   */
+  on(eventType, listener) {
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventType).add(listener);
+    return () => {
+      this.listeners.get(eventType)?.delete(listener);
+    };
+  }
+  /**
+   * Add listener for all events
+   */
+  onAny(listener) {
+    this.allListeners.add(listener);
+    return () => {
+      this.allListeners.delete(listener);
+    };
+  }
+  /**
+   * Remove event listener
+   */
+  off(eventType, listener) {
+    this.listeners.get(eventType)?.delete(listener);
+  }
+  /**
+   * Remove all listeners for an event type
+   */
+  offAll(eventType) {
+    if (eventType) {
+      this.listeners.delete(eventType);
+    } else {
+      this.listeners.clear();
+      this.allListeners.clear();
+    }
+  }
+  /**
+   * Listen for memory created events
+   */
+  onMemoryCreated(listener) {
+    return this.on("memory.created", listener);
+  }
+  /**
+   * Listen for memory updated events
+   */
+  onMemoryUpdated(listener) {
+    return this.on("memory.updated", listener);
+  }
+  /**
+   * Listen for memory deleted events
+   */
+  onMemoryDeleted(listener) {
+    return this.on("memory.deleted", listener);
+  }
+  /**
+   * Listen for memory tier changed events
+   */
+  onMemoryTierChanged(listener) {
+    return this.on("memory.tier_changed", listener);
+  }
+  /**
+   * Listen for graph node created events
+   */
+  onGraphNodeCreated(listener) {
+    return this.on("graph.node_created", listener);
+  }
+  /**
+   * Listen for graph edge created events
+   */
+  onGraphEdgeCreated(listener) {
+    return this.on("graph.edge_created", listener);
+  }
+  /**
+   * Listen for connection status changes
+   */
+  onConnectionStatus(listener) {
+    return this.on("connection.status", listener);
+  }
+  /**
+   * Wait for specific event (one-time)
+   */
+  once(eventType, timeout) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = timeout ? setTimeout(() => {
+        unsubscribe();
+        reject(new Error(`Timeout waiting for event: ${eventType}`));
+      }, timeout) : null;
+      const unsubscribe = this.on(eventType, (event) => {
+        if (timeoutId) clearTimeout(timeoutId);
+        unsubscribe();
+        resolve(event);
+      });
+    });
+  }
+  // ===========================================================================
+  // Private Methods
+  // ===========================================================================
+  send(message) {
+    const data = JSON.stringify(message);
+    if (this.isConnected && this.ws) {
+      this.ws.send(data);
+    } else {
+      if (this.messageQueue.length >= this.messageQueueSize) {
+        this.messageQueue.shift();
+      }
+      this.messageQueue.push(data);
+    }
+  }
+  sendSubscription(filter) {
+    this.send({
+      type: "subscribe",
+      filter: filter ?? {}
+    });
+  }
+  resubscribe() {
+    for (const filter of this.subscriptions) {
+      this.sendSubscription(filter);
+    }
+  }
+  flushMessageQueue() {
+    while (this.messageQueue.length > 0 && this.isConnected && this.ws) {
+      const message = this.messageQueue.shift();
+      if (message) {
+        this.ws.send(message);
+      }
+    }
+  }
+  handleMessage(event) {
+    try {
+      const data = JSON.parse(event.data);
+      this.emit(data);
+    } catch (error) {
+      console.error("Failed to parse WebSocket message:", error);
+    }
+  }
+  handleClose(event) {
+    this.stopHeartbeat();
+    if (event.code === 1e3) {
+      this.state = "disconnected";
+      this.emitStatusEvent("disconnected", "Connection closed normally");
+      return;
+    }
+    if (this.reconnectCount < this.reconnectAttempts) {
+      this.state = "reconnecting";
+      this.emitStatusEvent("reconnecting", `Reconnecting (attempt ${this.reconnectCount + 1}/${this.reconnectAttempts})`);
+      this.scheduleReconnect();
+    } else {
+      this.state = "disconnected";
+      this.emitStatusEvent("disconnected", "Max reconnection attempts reached");
+    }
+  }
+  handleError(_error) {
+    console.error("WebSocket error occurred");
+  }
+  scheduleReconnect() {
+    this.clearReconnectTimer();
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectCount);
+    this.reconnectCount++;
+    this.reconnectTimer = setTimeout(async () => {
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected) {
+        this.send({ type: "ping" });
+      }
+    }, this.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  emit(event) {
+    const typeListeners = this.listeners.get(event.type);
+    if (typeListeners) {
+      for (const listener of typeListeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error("Error in event listener:", error);
+        }
+      }
+    }
+    for (const listener of this.allListeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error("Error in event listener:", error);
+      }
+    }
+  }
+  emitStatusEvent(status, reason) {
+    const event = {
+      type: "connection.status",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status: status === "connecting" ? "reconnecting" : status,
+      reason
+    };
+    this.emit(event);
+  }
+};
+var CilowContext = react.createContext(null);
+function CilowProvider({
+  children,
+  userId: initialUserId,
+  sessionId: initialSessionId,
+  enableWebSocket = false,
+  ...config
+}) {
+  const [userId, setUserId] = react.useState(initialUserId);
+  const [sessionId, setSessionId] = react.useState(initialSessionId);
+  const [isConnected, setIsConnected] = react.useState(false);
+  const client = react.useMemo(() => new CilowClient(config), [config.apiUrl, config.apiKey]);
+  const ws = react.useMemo(() => {
+    if (!enableWebSocket) return null;
+    return new CilowWebSocket(config);
+  }, [enableWebSocket, config.apiUrl, config.apiKey]);
+  react.useEffect(() => {
+    if (!ws) return;
+    const connectWs = async () => {
+      try {
+        await ws.connect();
+        setIsConnected(true);
+      } catch (error) {
+        console.error("Failed to connect WebSocket:", error);
+      }
+    };
+    connectWs();
+    const unsubscribe = ws.onConnectionStatus((event) => {
+      setIsConnected(event.status === "connected");
+    });
+    return () => {
+      unsubscribe();
+      ws.disconnect();
+    };
+  }, [ws]);
+  react.useEffect(() => {
+    if (!ws || !userId) return;
+    ws.subscribe({ userId });
+  }, [ws, userId]);
+  const value = react.useMemo(
+    () => ({
+      client,
+      ws,
+      userId,
+      sessionId,
+      setUserId,
+      setSessionId,
+      isConnected
+    }),
+    [client, ws, userId, sessionId, isConnected]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(CilowContext.Provider, { value, children });
+}
+function useCilow() {
+  const context = react.useContext(CilowContext);
+  if (!context) {
+    throw new Error("useCilow must be used within a CilowProvider");
+  }
+  return context;
+}
+function useMemory() {
+  const { client, userId, sessionId } = useCilow();
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const remember = react.useCallback(
+    async (content, options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const memoryId = await client.remember(content, {
+          ...options,
+          userId: options?.userId ?? userId,
+          sessionId: options?.sessionId ?? sessionId
+        });
+        return memoryId;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, userId, sessionId]
+  );
+  const forget = react.useCallback(
+    async (filter) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const count = await client.forget({
+          ...filter,
+          userId
+        });
+        return count;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, userId]
+  );
+  const getMemory = react.useCallback(
+    async (memoryId) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        return await client.getMemory(memoryId);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client]
+  );
+  return { remember, forget, getMemory, isLoading, error };
+}
+function useRecall() {
+  const { client, userId } = useCilow();
+  const [data, setData] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const search = react.useCallback(
+    async (query, options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const results = await client.recall(query, {
+          ...options,
+          userId
+        });
+        setData(results);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setData([]);
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, userId]
+  );
+  const clear = react.useCallback(() => {
+    setData([]);
+    setError(null);
+  }, []);
+  return { data, search, clear, isLoading, error };
+}
+function useMemorySubscription(options) {
+  const { ws, isConnected } = useCilow();
+  const [latestEvent, setLatestEvent] = react.useState(null);
+  const [events, setEvents] = react.useState([]);
+  react.useEffect(() => {
+    if (!ws) return;
+    const unsubscribers = [];
+    const handleEvent = (event) => {
+      setLatestEvent(event);
+      setEvents((prev) => [...prev, event]);
+    };
+    const eventTypes = options?.eventTypes ?? [
+      "memory.created",
+      "memory.updated",
+      "memory.deleted"
+    ];
+    for (const eventType of eventTypes) {
+      if (eventType === "memory.created") {
+        unsubscribers.push(ws.onMemoryCreated(handleEvent));
+      } else if (eventType === "memory.updated") {
+        unsubscribers.push(ws.onMemoryUpdated(handleEvent));
+      } else if (eventType === "memory.deleted") {
+        unsubscribers.push(ws.onMemoryDeleted(handleEvent));
+      }
+    }
+    if (options?.userId || options?.sessionId || options?.tags) {
+      ws.subscribe({
+        userId: options.userId,
+        sessionId: options.sessionId,
+        tags: options.tags
+      });
+    }
+    return () => {
+      unsubscribers.forEach((unsub) => unsub());
+    };
+  }, [ws, options?.userId, options?.sessionId, options?.tags, options?.eventTypes]);
+  const clearEvents = react.useCallback(() => {
+    setEvents([]);
+    setLatestEvent(null);
+  }, []);
+  return { latestEvent, events, isConnected, clearEvents };
+}
+function useMemoryContext() {
+  const { client, userId } = useCilow();
+  const [context, setContext] = react.useState("");
+  const [memoriesUsed, setMemoriesUsed] = react.useState(0);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const getContext = react.useCallback(
+    async (query, options) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await client.getContext(query, {
+          ...options,
+          userId
+        });
+        setContext(result.context);
+        setMemoriesUsed(result.memoriesUsed);
+        return { context: result.context, memoriesUsed: result.memoriesUsed };
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, userId]
+  );
+  const clearContext = react.useCallback(() => {
+    setContext("");
+    setMemoriesUsed(0);
+  }, []);
+  return { getContext, context, memoriesUsed, clearContext, isLoading, error };
+}
+function useMemoryStats() {
+  const { client } = useCilow();
+  const [stats, setStats] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const refresh = react.useCallback(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const newStats = await client.getStats();
+      setStats(newStats);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  react.useEffect(() => {
+    refresh();
+  }, [refresh]);
+  return { stats, refresh, isLoading, error };
+}
+function useConversation() {
+  const { client, userId, sessionId } = useCilow();
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [storedCount, setStoredCount] = react.useState(0);
+  const storeConversation = react.useCallback(
+    async (userMessage, assistantResponse, metadata) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const memoryId = await client.storeConversation({
+          userMessage,
+          assistantResponse,
+          userId: userId ?? "anonymous",
+          sessionId,
+          metadata
+        });
+        setStoredCount((c) => c + 1);
+        return memoryId;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, userId, sessionId]
+  );
+  return { storeConversation, storedCount, isLoading, error };
+}
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = react.useState(value);
+  react.useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debouncedValue;
+}
+function useDebouncedSearch(options) {
+  const { client, userId } = useCilow();
+  const [query, setQuery] = react.useState("");
+  const [results, setResults] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const debouncedQuery = useDebounce(query, options?.delay ?? 300);
+  const minLength = options?.minLength ?? 2;
+  const limit = options?.limit ?? 10;
+  react.useEffect(() => {
+    if (debouncedQuery.length < minLength) {
+      setResults([]);
+      return;
+    }
+    const search = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const searchResults = await client.recall(debouncedQuery, {
+          limit,
+          userId
+        });
+        setResults(searchResults);
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setResults([]);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    search();
+  }, [debouncedQuery, client, userId, limit, minLength]);
+  const clear = react.useCallback(() => {
+    setQuery("");
+    setResults([]);
+    setError(null);
+  }, []);
+  return { query, setQuery, results, clear, isLoading, error };
+}
+
+exports.CilowProvider = CilowProvider;
+exports.useCilow = useCilow;
+exports.useConversation = useConversation;
+exports.useDebounce = useDebounce;
+exports.useDebouncedSearch = useDebouncedSearch;
+exports.useMemory = useMemory;
+exports.useMemoryContext = useMemoryContext;
+exports.useMemoryStats = useMemoryStats;
+exports.useMemorySubscription = useMemorySubscription;
+exports.useRecall = useRecall;
+//# sourceMappingURL=hooks.js.map
+//# sourceMappingURL=hooks.js.map