@cilow/sdk 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,482 +1,877 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AuthenticationError: () => AuthenticationError,
-  CilowClient: () => CilowClient,
-  CilowError: () => CilowError,
-  ConnectionError: () => ConnectionError,
-  NotFoundError: () => NotFoundError,
-  RateLimitError: () => RateLimitError,
-  ValidationError: () => ValidationError
-});
-module.exports = __toCommonJS(index_exports);
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/errors.ts
-var CilowError = class _CilowError extends Error {
-  constructor(message, statusCode, details) {
+// 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.name = "CilowError";
+    this.code = code;
     this.statusCode = statusCode;
     this.details = details;
-    Object.setPrototypeOf(this, _CilowError.prototype);
-  }
-};
-var ConnectionError = class _ConnectionError extends CilowError {
-  constructor(message, details) {
-    super(message, void 0, details);
-    this.name = "ConnectionError";
-    Object.setPrototypeOf(this, _ConnectionError.prototype);
-  }
-};
-var AuthenticationError = class _AuthenticationError extends CilowError {
-  constructor(message = "Invalid API key or unauthorized", details) {
-    super(message, 401, details);
-    this.name = "AuthenticationError";
-    Object.setPrototypeOf(this, _AuthenticationError.prototype);
-  }
-};
-var NotFoundError = class _NotFoundError extends CilowError {
-  constructor(message = "Resource not found", details) {
-    super(message, 404, details);
-    this.name = "NotFoundError";
-    Object.setPrototypeOf(this, _NotFoundError.prototype);
-  }
-};
-var ValidationError = class _ValidationError extends CilowError {
-  constructor(message = "Validation error", details) {
-    super(message, 422, details);
-    this.name = "ValidationError";
-    Object.setPrototypeOf(this, _ValidationError.prototype);
+    this.name = "CilowApiError";
   }
 };
-var RateLimitError = class _RateLimitError extends CilowError {
-  constructor(message = "Rate limit exceeded", retryAfter, details) {
-    super(message, 429, details);
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-    Object.setPrototypeOf(this, _RateLimitError.prototype);
-  }
-};
-
-// src/client.ts
-function toCamelCase(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => toCamelCase(item));
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-      const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-      acc[camelKey] = toCamelCase(value);
-      return acc;
-    }, {});
-  }
-  return obj;
-}
-function toSnakeCase(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map((item) => toSnakeCase(item));
-  }
-  if (obj !== null && typeof obj === "object") {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-      const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-      acc[snakeKey] = toSnakeCase(value);
-      return acc;
-    }, {});
-  }
-  return obj;
-}
 var CilowClient = class {
-  constructor(config = {}) {
-    this.baseUrl = (config.baseUrl ?? "http://localhost:8080").replace(/\/$/, "");
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/$/, "");
     this.apiKey = config.apiKey;
-    this.accessToken = config.accessToken;
     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
+    };
   }
   /**
-   * Set the JWT access token for Bearer authentication
-   */
-  setAccessToken(token) {
-    this.accessToken = token;
-  }
-  /**
-   * Make API request with error handling
+   * Make an API request
    */
-  async request(method, endpoint, data, useAuth = true) {
-    const url = `${this.baseUrl}/api/v1${endpoint}`;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (useAuth) {
-      if (this.apiKey) {
-        headers["X-API-Key"] = this.apiKey;
+  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));
+        }
       }
-      if (this.accessToken) {
-        headers["Authorization"] = `Bearer ${this.accessToken}`;
+      const queryString = params.toString();
+      if (queryString) {
+        url += `?${queryString}`;
       }
     }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-    try {
-      const response = await fetch(url, {
+    if (this.debug) {
+      console.log(`Cilow API: ${method} ${url}`);
+    }
+    const response = await fetchWithRetry(
+      url,
+      {
         method,
-        headers,
-        body: data ? JSON.stringify(toSnakeCase(data)) : void 0,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        const errorText = await response.text();
-        switch (response.status) {
-          case 401:
-            throw new AuthenticationError("Invalid API key or unauthorized");
-          case 404:
-            throw new NotFoundError(`Resource not found: ${endpoint}`);
-          case 422:
-            throw new ValidationError(`Validation error: ${errorText}`);
-          case 429:
-            const retryAfter = response.headers.get("Retry-After");
-            throw new RateLimitError(
-              "Rate limit exceeded",
-              retryAfter ? parseInt(retryAfter, 10) : void 0
-            );
-          default:
-            throw new CilowError(`API error ${response.status}: ${errorText}`, response.status);
-        }
-      }
-      const json = await response.json();
-      return toCamelCase(json);
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof CilowError) {
-        throw error;
-      }
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new ConnectionError("Request timeout");
-        }
-        throw new ConnectionError(`Failed to connect to Cilow API: ${error.message}`);
-      }
-      throw new ConnectionError("Unknown error occurred");
+        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);
   }
   // ===========================================================================
-  // Health & Status
+  // Simple API (remember, recall, forget)
   // ===========================================================================
   /**
-   * Check API server health
-   */
-  async healthCheck() {
-    const response = await fetch(`${this.baseUrl}/health`);
-    const json = await response.json();
-    return toCamelCase(json);
+   * 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 Operations
+  // Memory CRUD Operations
   // ===========================================================================
   /**
-   * Add a new memory to the system
+   * Create a new memory
    */
-  async addMemory(options) {
-    const response = await this.request("POST", "/memory/add", options);
-    return response.memoryId;
+  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, userId) {
-    const endpoint = userId ? `/memory/${memoryId}?user_id=${userId}` : `/memory/${memoryId}`;
-    return this.request("GET", endpoint);
+  async getMemory(memoryId) {
+    return this.request("GET", `/api/v1/memories/${memoryId}`);
   }
   /**
-   * Update an existing memory
+   * Update a memory
    */
-  async updateMemory(memoryId, options) {
-    return this.request("PUT", `/memory/${memoryId}`, options);
+  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", `/memory/${memoryId}`);
-    return true;
+    await this.request("DELETE", `/api/v1/memories/${memoryId}`);
   }
   /**
-   * Search memories with semantic similarity
+   * List memories with pagination
    */
-  async searchMemories(options) {
+  async listMemories(options) {
     const response = await this.request(
-      "POST",
-      "/memory/search",
-      options
+      "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
+      }
     );
-    return Array.isArray(response) ? response : response.memories ?? [];
+    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 memory system statistics
+   * Get context for AI applications
    */
-  async getMemoryStats() {
-    return this.request("GET", "/memory/stats");
+  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
+  // ===========================================================================
   /**
-   * List memories with pagination
+   * Store a conversation turn
    */
-  async listMemories(options) {
-    const params = new URLSearchParams();
-    if (options?.limit) params.set("limit", options.limit.toString());
-    if (options?.offset) params.set("offset", options.offset.toString());
-    if (options?.tags) params.set("tags", options.tags.join(","));
-    if (options?.userId) params.set("user_id", options.userId);
-    const endpoint = params.toString() ? `/memory/list?${params}` : "/memory/list";
-    const response = await this.request("GET", endpoint);
-    return Array.isArray(response) ? response : response.memories ?? [];
+  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;
   }
   // ===========================================================================
-  // Vector Operations
+  // Graph Operations
   // ===========================================================================
   /**
-   * Store a vector embedding directly
+   * Get a graph node
    */
-  async storeVector(options) {
-    const response = await this.request(
-      "POST",
-      "/vectors",
-      options
-    );
-    return response.vectorId ?? response.id ?? "";
+  async getGraphNode(nodeId) {
+    return this.request("GET", `/api/v1/graph/nodes/${nodeId}`);
   }
   /**
-   * Search for similar vectors
+   * Create a graph node
    */
-  async searchVectors(options) {
-    const response = await this.request("POST", "/vectors/search", options);
-    return response;
+  async createGraphNode(type, name, properties) {
+    return this.request("POST", "/api/v1/graph/nodes", {
+      type,
+      name,
+      properties: properties ?? {}
+    });
   }
   /**
-   * Get a vector by ID
+   * Create a graph edge
    */
-  async getVector(vectorId) {
-    return this.request("GET", `/vectors/${vectorId}`);
+  async createGraphEdge(sourceId, targetId, type, properties) {
+    return this.request("POST", "/api/v1/graph/edges", {
+      source_id: sourceId,
+      target_id: targetId,
+      type,
+      properties: properties ?? {}
+    });
   }
   /**
-   * Delete a vector
+   * Traverse the graph from a starting node
    */
-  async deleteVector(vectorId) {
-    await this.request("DELETE", `/vectors/${vectorId}`);
-    return true;
+  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"
+    });
   }
-  // ===========================================================================
-  // Graph Operations
-  // ===========================================================================
   /**
-   * Query the knowledge graph with natural language
+   * Get related nodes for a memory
    */
-  async queryGraph(query, limit = 10) {
+  async getRelatedNodes(memoryId) {
     const response = await this.request(
-      "POST",
-      "/graph/query",
-      { query, limit }
+      "GET",
+      `/api/v1/memories/${memoryId}/related-nodes`
     );
-    return Array.isArray(response) ? response : response.results ?? [];
+    return response.nodes ?? [];
   }
+  // ===========================================================================
+  // Statistics & Admin
+  // ===========================================================================
   /**
-   * Add a node to the knowledge graph
+   * Get memory statistics
    */
-  async addGraphNode(options) {
-    const response = await this.request(
-      "POST",
-      "/graph/nodes",
-      options
-    );
-    return response.nodeId ?? response.id ?? "";
+  async getStats() {
+    return this.request("GET", "/api/v1/stats");
   }
   /**
-   * Get a graph node by ID
+   * Get all tags with counts
    */
-  async getGraphNode(nodeId) {
-    return this.request("GET", `/graph/nodes/${nodeId}`);
+  async getTags() {
+    const response = await this.request("GET", "/api/v1/tags");
+    return response.tags ?? [];
   }
   /**
-   * Delete a graph node
+   * Get user statistics
    */
-  async deleteGraphNode(nodeId) {
-    await this.request("DELETE", `/graph/nodes/${nodeId}`);
-    return true;
+  async getUserStats(userId) {
+    return this.request("GET", `/api/v1/users/${userId}/stats`);
   }
   /**
-   * Get knowledge graph statistics
+   * Health check
    */
-  async getGraphStats() {
-    return this.request("GET", "/graph/stats");
+  async healthCheck() {
+    return this.request("GET", "/health");
   }
   // ===========================================================================
-  // Agent Operations
+  // Batch Operations
   // ===========================================================================
   /**
-   * Create a new AI agent
+   * 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 createAgent(options) {
-    const response = await this.request("POST", "/agents/create", {
-      name: options.name,
-      type: options.agentType ?? "react",
-      config: options.config
+  async batchDelete(memoryIds) {
+    const response = await this.request("DELETE", "/api/v1/memories/batch", {
+      ids: memoryIds
     });
-    return response.agentId;
+    return response.deleted ?? 0;
+  }
+};
+function createClient(config) {
+  return new CilowClient(config);
+}
+
+// src/types.ts
+function isMemoryEvent(event) {
+  return event.type.startsWith("memory.");
+}
+function isGraphEvent(event) {
+  return event.type.startsWith("graph.");
+}
+function isApiError(obj) {
+  return typeof obj === "object" && obj !== null && "code" in obj && "message" in obj;
+}
+
+// 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 agent details
+   * Get current connection state
    */
-  async getAgent(agentId) {
-    return this.request("GET", `/agents/${agentId}`);
+  get connectionState() {
+    return this.state;
   }
   /**
-   * Execute a task with an AI agent
+   * Check if connected
    */
-  async executeTask(agentId, options) {
-    return this.request("POST", `/agents/${agentId}/execute`, options);
+  get isConnected() {
+    return this.state === "connected";
   }
-  // ===========================================================================
-  // Fact Extraction
-  // ===========================================================================
   /**
-   * Extract facts from content using intelligent extraction
+   * Connect to the WebSocket server
    */
-  async extractFacts(content, sourceContext) {
-    const response = await this.request("POST", "/memory/extract", {
-      content,
-      sourceContext
+  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);
+      }
     });
-    return response.facts ?? [];
   }
-  // ===========================================================================
-  // Authentication Operations
-  // ===========================================================================
   /**
-   * Register a new user account
+   * Disconnect from the WebSocket server
    */
-  async register(email, password, name) {
-    const response = await this.request(
-      "POST",
-      "/auth/register",
-      { email, password, name },
-      false
-    );
-    this.accessToken = response.accessToken;
-    return response;
+  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");
   }
   /**
-   * Login with email and password
+   * Subscribe to events with optional filter
    */
-  async login(email, password) {
-    const response = await this.request(
-      "POST",
-      "/auth/login",
-      { email, password },
-      false
-    );
-    this.accessToken = response.accessToken;
-    return response;
+  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
+      });
+    }
   }
   /**
-   * Refresh the current access token
+   * Add event listener for specific event type
    */
-  async refreshToken() {
-    const response = await this.request("POST", "/auth/refresh");
-    this.accessToken = response.accessToken;
-    return response;
+  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);
+    };
   }
   /**
-   * Get the currently authenticated user
+   * Add listener for all events
    */
-  async getCurrentUser() {
-    return this.request("GET", "/auth/me");
+  onAny(listener) {
+    this.allListeners.add(listener);
+    return () => {
+      this.allListeners.delete(listener);
+    };
   }
   /**
-   * Logout and invalidate current session
+   * Remove event listener
    */
-  async logout() {
-    await this.request("POST", "/auth/logout");
-    this.accessToken = void 0;
-    return true;
+  off(eventType, listener) {
+    this.listeners.get(eventType)?.delete(listener);
   }
   /**
-   * Create a new API key for programmatic access
+   * Remove all listeners for an event type
    */
-  async createApiKey(options) {
-    const response = await this.request("POST", "/auth/api-keys", options);
-    return {
-      keyId: response.keyId ?? response.id ?? "",
-      name: response.name,
-      key: response.apiKey ?? response.key,
-      permissions: response.permissions ?? [],
-      expiresAt: response.expiresAt,
-      isActive: true
-    };
+  offAll(eventType) {
+    if (eventType) {
+      this.listeners.delete(eventType);
+    } else {
+      this.listeners.clear();
+      this.allListeners.clear();
+    }
   }
   /**
-   * List all API keys for the current user
+   * Listen for memory created events
    */
-  async listApiKeys() {
-    const response = await this.request("GET", "/auth/api-keys");
-    return Array.isArray(response) ? response : response.keys ?? [];
+  onMemoryCreated(listener) {
+    return this.on("memory.created", listener);
   }
   /**
-   * Revoke an API key
+   * Listen for memory updated events
    */
-  async revokeApiKey(keyId) {
-    await this.request("DELETE", `/auth/api-keys/${keyId}`);
-    return true;
+  onMemoryUpdated(listener) {
+    return this.on("memory.updated", listener);
   }
   /**
-   * List all active sessions for the current user
+   * Listen for memory deleted events
    */
-  async listSessions() {
-    const response = await this.request(
-      "GET",
-      "/auth/sessions"
-    );
-    return Array.isArray(response) ? response : response.sessions ?? [];
+  onMemoryDeleted(listener) {
+    return this.on("memory.deleted", listener);
   }
   /**
-   * Revoke a specific session
+   * Listen for memory tier changed events
    */
-  async revokeSession(sessionId) {
-    await this.request("DELETE", `/auth/sessions/${sessionId}`);
-    return true;
+  onMemoryTierChanged(listener) {
+    return this.on("memory.tier_changed", listener);
   }
   /**
-   * Revoke all sessions except the current one
+   * Listen for graph node created events
    */
-  async revokeAllSessions() {
-    await this.request("DELETE", "/auth/sessions");
-    return true;
+  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);
+  }
+};
+function createWebSocket(config) {
+  return new CilowWebSocket(config);
+}
+
+// src/index.ts
+var Cilow = class extends CilowClient {
+  constructor(config) {
+    super(config);
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AuthenticationError,
-  CilowClient,
-  CilowError,
-  ConnectionError,
-  NotFoundError,
-  RateLimitError,
-  ValidationError
-});
+function createCilow(config) {
+  return new Cilow(config);
+}
+var src_default = Cilow;
+
+exports.Cilow = Cilow;
+exports.CilowApiError = CilowApiError;
+exports.CilowClient = CilowClient;
+exports.CilowWebSocket = CilowWebSocket;
+exports.createCilow = createCilow;
+exports.createClient = createClient;
+exports.createWebSocket = createWebSocket;
+exports.default = src_default;
+exports.isApiError = isApiError;
+exports.isGraphEvent = isGraphEvent;
+exports.isMemoryEvent = isMemoryEvent;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map