@sovant/sdk 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,369 @@
+interface SovantConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+}
+interface Memory {
+    id: string;
+    content: string;
+    type: MemoryType;
+    importance: number;
+    created_at: string;
+    updated_at?: string;
+    user_id?: string;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    emotion?: EmotionalContext;
+    decisions?: string[];
+    questions?: string[];
+    action_items?: string[];
+    follow_up_required?: boolean;
+    follow_up_due?: string;
+    is_pinned?: boolean;
+    is_archived?: boolean;
+    title?: string;
+    thread_ids?: string[];
+}
+type MemoryType = "observation" | "reflection" | "decision" | "emotion" | "learning" | "preference" | "event" | "conversation" | "task" | "reminder" | "question" | "insight" | "journal" | "routine" | "meta";
+interface EmotionalContext {
+    type: EmotionType;
+    intensity?: number;
+    toneTags?: string[];
+}
+type EmotionType = "neutral" | "happy" | "excited" | "anxious" | "sad" | "stressed" | "calm" | "reflective" | "positive" | "negative";
+interface CreateMemoryInput {
+    content: string;
+    type?: MemoryType;
+    importance?: number;
+    metadata?: Record<string, any>;
+    tags?: string[];
+    emotion?: EmotionalContext;
+    decisions?: string[];
+    questions?: string[];
+    action_items?: string[];
+    follow_up_required?: boolean;
+    follow_up_due?: string;
+    title?: string;
+    thread_ids?: string[];
+}
+interface UpdateMemoryInput extends Partial<CreateMemoryInput> {
+    is_pinned?: boolean;
+    is_archived?: boolean;
+}
+interface SearchOptions {
+    query: string;
+    limit?: number;
+    offset?: number;
+    type?: MemoryType | MemoryType[];
+    tags?: string[];
+    created_after?: string;
+    created_before?: string;
+    search_type?: "semantic" | "keyword" | "hybrid";
+    include_archived?: boolean;
+    metadata_filters?: Record<string, any>;
+    sort_by?: "relevance" | "created_at" | "importance";
+    sort_order?: "asc" | "desc";
+}
+interface SearchResult extends Memory {
+    relevance_score: number;
+    highlights?: string[];
+}
+interface Thread {
+    id: string;
+    name: string;
+    description?: string;
+    memory_ids: string[];
+    status: "active" | "archived" | "completed";
+    metadata?: Record<string, any>;
+    tags?: string[];
+    created_at: string;
+    updated_at: string;
+    last_activity_at: string;
+    user_id?: string;
+}
+interface CreateThreadInput {
+    name: string;
+    description?: string;
+    memory_ids?: string[];
+    metadata?: Record<string, any>;
+    tags?: string[];
+    status?: "active" | "archived" | "completed";
+}
+interface UpdateThreadInput extends Partial<CreateThreadInput> {
+}
+interface ThreadStats {
+    memory_count: number;
+    memory_types: Record<string, number>;
+    emotion_types: Record<string, number>;
+    avg_importance: number;
+    follow_up_count: number;
+    earliest_memory: string;
+    latest_memory: string;
+    total_decisions: number;
+    total_questions: number;
+    total_action_items: number;
+}
+interface BatchCreateResult {
+    success: Memory[];
+    failed: Array<{
+        index: number;
+        error: string;
+    }>;
+    success_count: number;
+    failed_count: number;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    total: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+}
+interface APIError {
+    error: string;
+    message: string;
+    status_code: number;
+    details?: Record<string, any>;
+}
+
+declare class BaseClient {
+    protected config: Required<SovantConfig>;
+    constructor(config: SovantConfig);
+    protected request<T>(method: string, path: string, data?: any, retryCount?: number): Promise<T>;
+    private handleErrorResponse;
+    private delay;
+    protected buildQueryString(params: Record<string, any>): string;
+}
+
+declare class Memories extends BaseClient {
+    /**
+     * Create a new memory
+     */
+    create(data: CreateMemoryInput): Promise<Memory>;
+    /**
+     * Get a memory by ID
+     */
+    get(id: string): Promise<Memory>;
+    /**
+     * Update a memory
+     */
+    update(id: string, data: UpdateMemoryInput): Promise<Memory>;
+    /**
+     * Delete a memory
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List memories with pagination
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        type?: string | string[];
+        tags?: string[];
+        is_archived?: boolean;
+        sort_by?: "created_at" | "importance" | "updated_at";
+        sort_order?: "asc" | "desc";
+    }): Promise<PaginatedResponse<Memory>>;
+    /**
+     * Search memories
+     */
+    search(options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Batch create memories
+     */
+    createBatch(memories: CreateMemoryInput[]): Promise<BatchCreateResult>;
+    /**
+     * Batch delete memories
+     */
+    deleteBatch(ids: string[]): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Get memory insights and analytics
+     */
+    getInsights(options?: {
+        time_range?: "last_7_days" | "last_30_days" | "last_90_days" | "all_time";
+        group_by?: "type" | "emotion" | "date";
+    }): Promise<{
+        total_count: number;
+        type_distribution: Record<string, number>;
+        emotion_distribution: Record<string, number>;
+        importance_stats: {
+            avg: number;
+            min: number;
+            max: number;
+        };
+        growth_rate: number;
+        most_common_tags: Array<{
+            tag: string;
+            count: number;
+        }>;
+    }>;
+    /**
+     * Archive a memory
+     */
+    archive(id: string): Promise<Memory>;
+    /**
+     * Unarchive a memory
+     */
+    unarchive(id: string): Promise<Memory>;
+    /**
+     * Pin a memory
+     */
+    pin(id: string): Promise<Memory>;
+    /**
+     * Unpin a memory
+     */
+    unpin(id: string): Promise<Memory>;
+    /**
+     * Get related memories
+     */
+    getRelated(id: string, options?: {
+        limit?: number;
+        threshold?: number;
+    }): Promise<SearchResult[]>;
+}
+
+declare class Threads extends BaseClient {
+    /**
+     * Create a new thread
+     */
+    create(data: CreateThreadInput): Promise<Thread>;
+    /**
+     * Get a thread by ID
+     */
+    get(id: string, includeMemories?: boolean): Promise<Thread & {
+        memories?: Memory[];
+    }>;
+    /**
+     * Update a thread
+     */
+    update(id: string, data: UpdateThreadInput): Promise<Thread>;
+    /**
+     * Delete a thread
+     */
+    delete(id: string, deleteMemories?: boolean): Promise<void>;
+    /**
+     * List threads with pagination
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+        status?: "active" | "archived" | "completed";
+        tags?: string[];
+        sort_by?: "created_at" | "updated_at" | "last_activity_at" | "name";
+        sort_order?: "asc" | "desc";
+    }): Promise<PaginatedResponse<Thread>>;
+    /**
+     * Add memories to a thread
+     */
+    addMemories(id: string, memoryIds: string[]): Promise<Thread>;
+    /**
+     * Remove memories from a thread
+     */
+    removeMemories(id: string, memoryIds: string[]): Promise<Thread>;
+    /**
+     * Get memories in a thread
+     */
+    getMemories(id: string, options?: {
+        limit?: number;
+        offset?: number;
+        type?: string | string[];
+        sort_by?: "created_at" | "importance";
+        sort_order?: "asc" | "desc";
+    }): Promise<PaginatedResponse<Memory>>;
+    /**
+     * Get thread statistics
+     */
+    getStats(id: string): Promise<ThreadStats>;
+    /**
+     * Archive a thread
+     */
+    archive(id: string): Promise<Thread>;
+    /**
+     * Unarchive a thread
+     */
+    unarchive(id: string): Promise<Thread>;
+    /**
+     * Complete a thread
+     */
+    complete(id: string): Promise<Thread>;
+    /**
+     * Search threads
+     */
+    search(options: {
+        query: string;
+        limit?: number;
+        offset?: number;
+        status?: "active" | "archived" | "completed";
+        tags?: string[];
+    }): Promise<PaginatedResponse<Thread>>;
+    /**
+     * Merge multiple threads into one
+     */
+    merge(targetId: string, sourceIds: string[]): Promise<Thread>;
+    /**
+     * Clone a thread
+     */
+    clone(id: string, options?: {
+        name?: string;
+        include_memories?: boolean;
+    }): Promise<Thread>;
+}
+
+declare class SovantError extends Error {
+    statusCode?: number;
+    details?: Record<string, any>;
+    constructor(message: string, statusCode?: number, details?: Record<string, any>);
+}
+declare class AuthenticationError extends SovantError {
+    constructor(message?: string);
+}
+declare class RateLimitError extends SovantError {
+    retryAfter?: number;
+    constructor(message?: string, retryAfter?: number);
+}
+declare class ValidationError extends SovantError {
+    errors?: Record<string, string[]>;
+    constructor(message?: string, errors?: Record<string, string[]>);
+}
+declare class NotFoundError extends SovantError {
+    constructor(message?: string);
+}
+declare class NetworkError extends SovantError {
+    constructor(message?: string);
+}
+
+declare class SovantClient {
+    memories: Memories;
+    threads: Threads;
+    private config;
+    constructor(apiKeyOrConfig: string | SovantConfig);
+    /**
+     * Test API connection
+     */
+    ping(): Promise<{
+        status: "ok";
+        timestamp: string;
+    }>;
+    /**
+     * Get current API usage and quota
+     */
+    getUsage(): Promise<{
+        quota: {
+            total: number;
+            used: number;
+            remaining: number;
+            reset_at: string;
+        };
+        usage: {
+            memories_created: number;
+            searches_performed: number;
+            threads_created: number;
+        };
+    }>;
+}
+
+export { type APIError, AuthenticationError, type BatchCreateResult, type CreateMemoryInput, type CreateThreadInput, type EmotionType, type EmotionalContext, type Memory, type MemoryType, NetworkError, NotFoundError, type PaginatedResponse, RateLimitError, type SearchOptions, type SearchResult, SovantClient, type SovantConfig, SovantError, type Thread, type ThreadStats, type UpdateMemoryInput, type UpdateThreadInput, ValidationError, SovantClient as default };