@cilow/sdk 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,877 +1,17 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// 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;
-  }
-};
-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 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);
-  }
-};
-function createWebSocket(config) {
-  return new CilowWebSocket(config);
-}
-
-// src/index.ts
-var Cilow = class extends CilowClient {
-  constructor(config) {
-    super(config);
-  }
-};
-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
+/**
+ * @cilow/sdk — TypeScript client for Cilow, the verifiable context layer for AI agents.
+ *
+ * Point it at a running cilow-serve and call the FOUR core verbs (the MCP core profile):
+ * `ingest` (the one write door: facts | text | bytes | url), `contextPack` (the product read:
+ * injectible pack + citations with `is_current` + `abstained` / `grounding` / `trace_id`),
+ * `forget` (withdraw), and `explain` (why a read surfaced what it surfaced, via `trace_id`).
+ * `remember` / `recall` / `answer` / `timeline` / `trackEntity` remain as full-profile / legacy
+ * aliases. The headline feature is CALIBRATED ABSTENTION: reads return `abstained: true` when the
+ * engine does not know, instead of fabricating. Gate your agent on that flag.
+ */
+export { CilowClient, nowMicros, ingestSourceId } from "./client.js";
+export { sha256Hex, canonicalJson } from "./hash.js";
+export { CilowError } from "./errors.js";
+export { TERMINAL_LAYERS } from "./types.js";
+export { isInfrastructureAbstain, isCalibratedAbstain, shouldRetry, stoppedAt, isGrounded, } from "./abstain.js";
 //# sourceMappingURL=index.js.map