@cilow/sdk 0.2.0 → 0.2.1

package/dist/index.d.mts

@@ -1,407 +1,111 @@
-/**
- * Cilow SDK Type Definitions
- */
-declare enum MemoryTier {
-    HOT = "hot",
-    WARM = "warm",
-    COLD = "cold"
-}
-declare enum FactType {
-    PERSONAL = "Personal",
-    PREFERENCE = "Preference",
-    SKILL = "Skill",
-    GOAL = "Goal",
-    RELATIONSHIP = "Relationship",
-    CONTEXTUAL = "Contextual",
-    TEMPORAL = "Temporal",
-    CAUSAL = "Causal"
-}
-declare enum EntityType {
-    PERSON = "Person",
-    PLACE = "Place",
-    ORGANIZATION = "Organization",
-    OBJECT = "Object",
-    CONCEPT = "Concept",
-    EVENT = "Event",
-    TIME = "Time",
-    SKILL = "Skill",
-    PREFERENCE = "Preference"
-}
-interface Entity {
-    name: string;
-    entityType: EntityType;
-    confidence: number;
-    attributes?: Record<string, string>;
-}
-interface Relationship {
-    source: string;
-    relationshipType: string;
-    target: string;
-    confidence: number;
-    context?: string;
-}
-interface ExtractedFact {
-    id: string;
-    statement: string;
-    confidence: number;
-    factType: FactType;
-    entities: Entity[];
-    relationships: Relationship[];
-    extractedAt?: string;
-}
-interface Memory {
-    id: string;
-    content: string;
-    compressedContent?: string;
-    createdAt?: string;
-    updatedAt?: string;
-    tier: MemoryTier;
-    salience: number;
-    accessCount: number;
-    tags: string[];
-    metadata: Record<string, unknown>;
-    facts?: ExtractedFact[];
-    embedding?: number[];
-    userId?: string;
-}
-interface MemoryStats {
-    totalMemories: number;
-    hotTierCount: number;
-    warmTierCount: number;
-    coldTierCount: number;
-    avgSalience: number;
-    totalTokens: number;
-    totalEmbeddings: number;
-}
-interface SearchResult {
-    memory: Memory;
-    score: number;
-    rank: number;
-}
-interface HealthStatus {
-    status: string;
-    version: string;
-    uptimeSeconds?: number;
-    memoryUsageMb?: number;
-    agentsActive?: number;
-}
-interface AgentConfig {
-    name: string;
-    agentType?: string;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    contextLimit?: number;
-}
-interface Agent {
-    id: string;
-    name: string;
-    agentType: string;
-    createdAt: string;
-    config: Record<string, unknown>;
-}
-interface AgentExecutionResult {
-    success: boolean;
-    response: string;
-    reasoning?: string;
-    memoriesUsed: string[];
-    tokensUsed: number;
-    executionTimeMs: number;
-}
-interface User {
-    id: string;
-    email: string;
-    name?: string;
-    avatarUrl?: string;
-    emailVerified: boolean;
-    createdAt?: string;
-}
-interface AuthResponse {
-    accessToken: string;
-    tokenType: string;
-    expiresIn: number;
-    refreshToken?: string;
-    user: User;
-}
-interface ApiKey {
-    keyId: string;
-    name: string;
-    key?: string;
-    permissions: string[];
-    createdAt?: string;
-    expiresAt?: string;
-    lastUsedAt?: string;
-    ipWhitelist?: string[];
-    isActive: boolean;
-}
-interface Session {
-    sessionId: string;
-    deviceInfo?: string;
-    ipAddress?: string;
-    createdAt?: string;
-    lastActiveAt?: string;
-}
-interface AddMemoryOptions {
-    content: string;
-    metadata?: Record<string, unknown>;
-    tags?: string[];
-    userId?: string;
-}
-interface SearchMemoriesOptions {
-    query: string;
-    limit?: number;
-    tags?: string[];
-    tagMode?: 'any' | 'all';
-    minRelevance?: number;
-    userId?: string;
-}
-interface CreateAgentOptions {
-    name: string;
-    agentType?: string;
-    config?: AgentConfig;
-}
-interface ExecuteTaskOptions {
-    task: string;
-    contextLimit?: number;
-    includeReasoning?: boolean;
-}
-interface CreateApiKeyOptions {
-    name: string;
-    permissions?: string[];
-    expiresInDays?: number;
-    ipWhitelist?: string[];
-}
-interface CilowClientConfig {
-    baseUrl?: string;
-    apiKey?: string;
-    accessToken?: string;
-    timeout?: number;
-}
+import { CilowClient } from './client.mjs';
+export { CilowApiError, createClient } from './client.mjs';
+import { CilowConfig } from './types.mjs';
+export { AdvancedSearchOptions, ApiError, BaseEvent, BatchResult, CilowEvent, ConnectionStatusEvent, ContextResult, ConversationTurn, CreateMemoryOptions, FullCilowConfig, GraphEdge, GraphEdgeCreatedEvent, GraphNode, GraphNodeCreatedEvent, GraphSubgraph, GraphTraversalOptions, HealthCheck, Memory, MemoryCreatedEvent, MemoryDeletedEvent, MemoryStats, MemoryStatus, MemorySummary, MemoryTier, MemoryTierChangedEvent, MemoryUpdatedEvent, PaginatedResponse, PaginationParams, SearchQuery, SearchResult, TagCount, UpdateMemoryOptions, UserStats, WebSocketConfig, isApiError, isGraphEvent, isMemoryEvent } from './types.mjs';
+export { CilowWebSocket, ConnectionState, EventListener, SubscriptionFilter, createWebSocket } from './websocket.mjs';
 
 /**
- * Cilow TypeScript SDK Client
- * Async-first client for the Cilow AI Agent Platform
+ * @cilow/sdk - Complete TypeScript SDK for Cilow AI Memory Infrastructure
+ *
+ * Cilow provides a multi-tier memory system for AI applications, enabling
+ * persistent context, semantic search, and knowledge graph capabilities.
+ *
+ * @packageDocumentation
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { Cilow } from '@cilow/sdk';
+ *
+ * const cilow = new Cilow({
+ *   apiUrl: 'https://api.cilow.ai',
+ *   apiKey: 'your-api-key'
+ * });
+ *
+ * // Store a memory
+ * await cilow.remember("User prefers dark mode", { tags: ["preference"] });
+ *
+ * // Search memories
+ * const memories = await cilow.recall("user preferences");
+ *
+ * // Delete memories
+ * await cilow.forget({ tags: ["old"] });
+ * ```
+ *
+ * @example Vercel AI SDK Integration
+ * ```typescript
+ * import { createCilowTools } from '@cilow/sdk/providers/vercel';
+ * import { streamText } from 'ai';
+ *
+ * const tools = createCilowTools({
+ *   apiUrl: 'https://api.cilow.ai',
+ *   apiKey: 'your-key'
+ * });
+ *
+ * const result = await streamText({
+ *   model: anthropic('claude-sonnet-4-20250514'),
+ *   tools,
+ *   prompt: 'What do you remember about me?'
+ * });
+ * ```
+ *
+ * @example React Integration
+ * ```typescript
+ * import { CilowProvider, useMemory, useRecall } from '@cilow/sdk/react';
+ *
+ * function App() {
+ *   return (
+ *     <CilowProvider apiUrl="https://api.cilow.ai" apiKey="your-key">
+ *       <MemoryComponent />
+ *     </CilowProvider>
+ *   );
+ * }
+ * ```
  */
 
 /**
- * CilowClient - TypeScript client for Cilow AI Agent Platform
+ * Cilow - Main entry point for the Cilow SDK
+ *
+ * This is an alias for CilowClient with a simpler name for common usage.
  *
  * @example
  * ```typescript
- * const client = new CilowClient({ apiKey: 'cilow_xxx' });
+ * import { Cilow } from '@cilow/sdk';
  *
- * // Add a memory
- * const memoryId = await client.addMemory({ content: 'User prefers Python' });
+ * const cilow = new Cilow({
+ *   apiUrl: 'https://api.cilow.ai',
+ *   apiKey: 'your-api-key'
+ * });
  *
- * // Search memories
- * const results = await client.searchMemories({ query: 'programming' });
+ * // Simple API
+ * await cilow.remember("User prefers dark mode", { tags: ["preference"] });
+ * const memories = await cilow.recall("user preferences");
+ * await cilow.forget({ tags: ["old"] });
  *
- * // Create an agent
- * const agentId = await client.createAgent({ name: 'assistant' });
+ * // Full API
+ * const memory = await cilow.getMemory("mem-123");
+ * const stats = await cilow.getStats();
+ * const context = await cilow.getContext("recent discussions");
  * ```
  */
-declare class CilowClient {
-    private readonly baseUrl;
-    private readonly apiKey?;
-    private accessToken?;
-    private readonly timeout;
-    constructor(config?: CilowClientConfig);
-    /**
-     * Set the JWT access token for Bearer authentication
-     */
-    setAccessToken(token: string): void;
-    /**
-     * Make API request with error handling
-     */
-    private request;
-    /**
-     * Check API server health
-     */
-    healthCheck(): Promise<HealthStatus>;
-    /**
-     * Add a new memory to the system
-     */
-    addMemory(options: AddMemoryOptions): Promise<string>;
-    /**
-     * Get a memory by ID
-     */
-    getMemory(memoryId: string, userId?: string): Promise<Memory>;
-    /**
-     * Update an existing memory
-     */
-    updateMemory(memoryId: string, options: Partial<AddMemoryOptions>): Promise<{
-        memoryId: string;
-        message: string;
-    }>;
-    /**
-     * Delete a memory
-     */
-    deleteMemory(memoryId: string): Promise<boolean>;
-    /**
-     * Search memories with semantic similarity
-     */
-    searchMemories(options: SearchMemoriesOptions): Promise<SearchResult[]>;
-    /**
-     * Get memory system statistics
-     */
-    getMemoryStats(): Promise<MemoryStats>;
-    /**
-     * List memories with pagination
-     */
-    listMemories(options?: {
-        limit?: number;
-        offset?: number;
-        tags?: string[];
-        userId?: string;
-    }): Promise<Memory[]>;
-    /**
-     * Store a vector embedding directly
-     */
-    storeVector(options: {
-        embedding: number[];
-        metadata?: Record<string, unknown>;
-        content?: string;
-    }): Promise<string>;
-    /**
-     * Search for similar vectors
-     */
-    searchVectors(options: {
-        embedding: number[];
-        limit?: number;
-        minScore?: number;
-    }): Promise<Array<{
-        id: string;
-        score: number;
-        metadata?: Record<string, unknown>;
-    }>>;
-    /**
-     * Get a vector by ID
-     */
-    getVector(vectorId: string): Promise<{
-        id: string;
-        embedding: number[];
-        metadata?: Record<string, unknown>;
-    }>;
-    /**
-     * Delete a vector
-     */
-    deleteVector(vectorId: string): Promise<boolean>;
-    /**
-     * Query the knowledge graph with natural language
-     */
-    queryGraph(query: string, limit?: number): Promise<unknown[]>;
-    /**
-     * Add a node to the knowledge graph
-     */
-    addGraphNode(options: {
-        label: string;
-        properties: Record<string, unknown>;
-        nodeType?: string;
-    }): Promise<string>;
-    /**
-     * Get a graph node by ID
-     */
-    getGraphNode(nodeId: string): Promise<{
-        id: string;
-        label: string;
-        properties: Record<string, unknown>;
-    }>;
-    /**
-     * Delete a graph node
-     */
-    deleteGraphNode(nodeId: string): Promise<boolean>;
-    /**
-     * Get knowledge graph statistics
-     */
-    getGraphStats(): Promise<{
-        nodeCount: number;
-        edgeCount: number;
-    }>;
-    /**
-     * Create a new AI agent
-     */
-    createAgent(options: CreateAgentOptions): Promise<string>;
-    /**
-     * Get agent details
-     */
-    getAgent(agentId: string): Promise<Agent>;
-    /**
-     * Execute a task with an AI agent
-     */
-    executeTask(agentId: string, options: ExecuteTaskOptions): Promise<AgentExecutionResult>;
-    /**
-     * Extract facts from content using intelligent extraction
-     */
-    extractFacts(content: string, sourceContext?: string): Promise<ExtractedFact[]>;
-    /**
-     * Register a new user account
-     */
-    register(email: string, password: string, name?: string): Promise<AuthResponse>;
-    /**
-     * Login with email and password
-     */
-    login(email: string, password: string): Promise<AuthResponse>;
-    /**
-     * Refresh the current access token
-     */
-    refreshToken(): Promise<AuthResponse>;
-    /**
-     * Get the currently authenticated user
-     */
-    getCurrentUser(): Promise<User>;
-    /**
-     * Logout and invalidate current session
-     */
-    logout(): Promise<boolean>;
-    /**
-     * Create a new API key for programmatic access
-     */
-    createApiKey(options: CreateApiKeyOptions): Promise<ApiKey>;
-    /**
-     * List all API keys for the current user
-     */
-    listApiKeys(): Promise<ApiKey[]>;
-    /**
-     * Revoke an API key
-     */
-    revokeApiKey(keyId: string): Promise<boolean>;
-    /**
-     * List all active sessions for the current user
-     */
-    listSessions(): Promise<Session[]>;
-    /**
-     * Revoke a specific session
-     */
-    revokeSession(sessionId: string): Promise<boolean>;
-    /**
-     * Revoke all sessions except the current one
-     */
-    revokeAllSessions(): Promise<boolean>;
+declare class Cilow extends CilowClient {
+    constructor(config: CilowConfig);
 }
-
 /**
- * Cilow SDK Error Classes
+ * Create a Cilow instance (convenience function)
+ *
+ * @param config - Configuration options
+ * @returns Cilow client instance
+ *
+ * @example
+ * ```typescript
+ * import { createCilow } from '@cilow/sdk';
+ *
+ * const cilow = createCilow({
+ *   apiUrl: 'https://api.cilow.ai',
+ *   apiKey: 'your-api-key'
+ * });
+ * ```
  */
-declare class CilowError extends Error {
-    readonly statusCode?: number;
-    readonly details?: unknown;
-    constructor(message: string, statusCode?: number, details?: unknown);
-}
-declare class ConnectionError extends CilowError {
-    constructor(message: string, details?: unknown);
-}
-declare class AuthenticationError extends CilowError {
-    constructor(message?: string, details?: unknown);
-}
-declare class NotFoundError extends CilowError {
-    constructor(message?: string, details?: unknown);
-}
-declare class ValidationError extends CilowError {
-    constructor(message?: string, details?: unknown);
-}
-declare class RateLimitError extends CilowError {
-    readonly retryAfter?: number;
-    constructor(message?: string, retryAfter?: number, details?: unknown);
-}
+declare function createCilow(config: CilowConfig): Cilow;
 
-export { type AddMemoryOptions, type Agent, type AgentConfig, type AgentExecutionResult, type ApiKey, type AuthResponse, AuthenticationError, CilowClient, type CilowClientConfig, CilowError, ConnectionError, type CreateAgentOptions, type CreateApiKeyOptions, type Entity, EntityType, type ExecuteTaskOptions, type ExtractedFact, FactType, type HealthStatus, type Memory, type MemoryStats, MemoryTier, NotFoundError, RateLimitError, type Relationship, type SearchMemoriesOptions, type SearchResult, type Session, type User, ValidationError };
+export { Cilow, CilowClient, CilowConfig, createCilow, Cilow as default };