@cilow/sdk 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,407 @@
+/**
+ * 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;
+}
+
+/**
+ * Cilow TypeScript SDK Client
+ * Async-first client for the Cilow AI Agent Platform
+ */
+
+/**
+ * CilowClient - TypeScript client for Cilow AI Agent Platform
+ *
+ * @example
+ * ```typescript
+ * const client = new CilowClient({ apiKey: 'cilow_xxx' });
+ *
+ * // Add a memory
+ * const memoryId = await client.addMemory({ content: 'User prefers Python' });
+ *
+ * // Search memories
+ * const results = await client.searchMemories({ query: 'programming' });
+ *
+ * // Create an agent
+ * const agentId = await client.createAgent({ name: 'assistant' });
+ * ```
+ */
+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>;
+}
+
+/**
+ * Cilow SDK Error Classes
+ */
+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);
+}
+
+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 };