@sovant/sdk 1.0.5 → 1.1.1

package/dist/index.d.ts

@@ -1,47 +1,433 @@
-export type SovantClientOptions = {
+/**
+ * HTTP Client for Sovant SDK - v1 Core
+ * Handles retries, timeouts, and error handling
+ */
+interface HttpOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: any;
+    timeout?: number;
+    maxRetries?: number;
+    debug?: boolean;
+}
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+    requestId?: string;
+}
+declare class HttpClient {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    private readonly globalOptions;
+    constructor(baseUrl: string, apiKey: string, globalOptions?: Partial<HttpOptions>);
+    request<T = any>(path: string, options?: HttpOptions): Promise<HttpResponse<T>>;
+    private makeRequest;
+    private calculateRetryDelay;
+    private sleep;
+}
+
+/**
+ * Sovant SDK Types - v1 Core
+ * Single source of truth - DO NOT DEVIATE
+ */
+type MemoryType = 'journal' | 'insight' | 'observation' | 'task' | 'preference';
+interface MemoryResponse {
+    id: string;
+    thread_id: string | null;
+    content: string;
+    type: MemoryType;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateMemoryInput {
+    content: string;
+    type: MemoryType;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    thread_id?: string;
+}
+interface UpdateMemoryInput {
+    content: string;
+    type: MemoryType;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    is_archived?: boolean;
+    thread_id?: string | null;
+}
+interface PutMemoryInput extends CreateMemoryInput {
+}
+interface ListParams {
+    limit?: number;
+    offset?: number;
+    type?: MemoryType;
+    tags?: string[];
+    thread_id?: string;
+    is_archived?: boolean;
+}
+interface ListResponse {
+    memories: MemoryResponse[];
+    total: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+}
+interface SearchParams {
+    query?: string;
+    type?: MemoryType;
+    tags?: string[];
+    from_date?: string;
+    to_date?: string;
+    limit?: number;
+    thread_id?: string;
+}
+interface SearchHit extends MemoryResponse {
+    score: number;
+}
+interface SearchResponse {
+    results: SearchHit[];
+}
+type BatchOp = {
+    op: 'create';
+    data: CreateMemoryInput;
+} | {
+    op: 'update';
+    id: string;
+    data: Partial<UpdateMemoryInput>;
+} | {
+    op: 'delete';
+    id: string;
+};
+interface BatchRequest {
+    operations: BatchOp[];
+}
+interface BatchResult {
+    operation: 'create' | 'update' | 'delete';
+    index: number;
+    success: boolean;
+    id?: string;
+    data?: any;
+    error?: string;
+}
+interface BatchResponse {
+    results: BatchResult[];
+    summary: {
+        total: number;
+        successful: number;
+        failed: number;
+        operations: {
+            create: number;
+            update: number;
+            delete: number;
+        };
+    };
+    transaction_id: string;
+}
+interface CreateResponse extends MemoryResponse {
+    ok: true;
+}
+interface Thread {
+    id: string;
+    title: string | null;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateThreadInput {
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateThreadInput {
+    title?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ThreadListResponse {
+    threads: Thread[];
+    total: number;
+    limit: number;
+    offset: number;
+    has_more: boolean;
+}
+interface ThreadWithMemories extends Thread {
+    memories: {
+        items: MemoryResponse[];
+        total: number;
+        limit: number;
+        offset: number;
+        has_more: boolean;
+    };
+}
+interface LinkMemoryResponse {
+    ok: boolean;
+    thread_id: string;
+    memory_id: string;
+}
+interface DeleteResponse {
+    ok: true;
+}
+interface SovantConfig {
     apiKey: string;
     baseUrl?: string;
-    timeoutMs?: number;
-};
-export declare class Sovant {
-    private apiKey;
-    private baseUrl;
-    private timeout;
-    constructor(opts: SovantClientOptions);
-    private req;
-    memory: {
-        create: <T = any>(input: {
-            data: T;
-            type?: "journal" | "insight" | "observation" | "task" | "preference";
-            ttl?: string;
-            tags?: string[];
-            metadata?: Record<string, any>;
-            thread_id?: string;
-        }) => Promise<unknown>;
-        get: (id: string) => Promise<unknown>;
-        search: (q: {
-            query?: string;
-            type?: string;
-            tags?: string[];
-            thread_id?: string;
-            limit?: number;
-            from_date?: string;
-            to_date?: string;
-        }) => Promise<unknown>;
-        update: <T = any>(id: string, patch: Partial<{
-            data: T;
-            type?: string;
-            ttl?: string;
-            tags?: string[];
-            metadata?: Record<string, any>;
-        }>) => Promise<unknown>;
-        delete: (id: string) => Promise<unknown>;
+    timeout?: number;
+    maxRetries?: number;
+    debug?: boolean;
+}
+interface Session {
+    id: string;
+    user_id: string;
+    title: string;
+    capture_enabled?: boolean;
+    use_memory?: boolean;
+    summary_data?: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+}
+interface CreateSessionInput {
+    provider?: 'openai' | 'anthropic' | 'google';
+    model?: string;
+    title?: string;
+}
+interface Message {
+    id: string;
+    session_id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    provider?: string;
+    model?: string;
+    created_at: string;
+}
+interface SendMessageOptions {
+    message?: string;
+    provider?: string;
+    model?: string;
+    useMemory?: boolean;
+    captureToMemory?: boolean;
+    stream?: boolean;
+    signal?: AbortSignal;
+}
+interface StreamEvent {
+    type: 'delta' | 'done' | 'error';
+    data?: string;
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    key?: string;
+    prefix?: string;
+    created_at: string;
+    expires_at?: string;
+    last_used_at?: string;
+}
+interface UpdateKeyInput {
+    name?: string;
+    expires_at?: string;
+}
+type ProfileEntity = 'name' | 'age' | 'location' | 'preference';
+interface ProfileExtraction {
+    entity: ProfileEntity | null;
+    value?: string;
+}
+interface ProfileFacts {
+    name?: string;
+    age?: string;
+    location?: string;
+    preferences?: string[];
+}
+
+/**
+ * Sovant SDK Error Classes - v1 Core
+ */
+declare class SovantError extends Error {
+    readonly code?: string;
+    readonly status?: number;
+    readonly requestId?: string;
+    constructor(message: string, code?: string, status?: number, requestId?: string);
+    static fromResponse(status: number, body: any, requestId?: string): SovantError;
+    toJSON(): {
+        name: string;
+        message: string;
+        code: string | undefined;
+        status: number | undefined;
+        requestId: string | undefined;
     };
 }
-export declare class SovantError extends Error {
-    code: string;
-    status?: number;
-    details?: any;
-    constructor(message: string, code: string, status?: number, details?: any);
+declare class NetworkError extends SovantError {
+    constructor(message: string, cause?: Error);
+}
+declare class TimeoutError extends SovantError {
+    constructor(message?: string);
+}
+
+/**
+ * Sovant SDK - v1.1.0
+ * Universal Memory API for AI Applications
+ */
+
+/**
+ * Main Sovant SDK Client
+ */
+declare class Sovant {
+    private readonly http;
+    readonly memory: MemoryNamespace;
+    readonly threads: ThreadsNamespace;
+    readonly chat: ChatNamespace;
+    readonly keys: KeysNamespace;
+    readonly recall: RecallNamespace;
+    constructor(config: SovantConfig);
+}
+/**
+ * Memory namespace for all memory-related operations
+ */
+declare class MemoryNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new memory
+     */
+    create(input: CreateMemoryInput): Promise<MemoryResponse>;
+    /**
+     * List memories with optional filters
+     */
+    list(params?: ListParams): Promise<ListResponse>;
+    /**
+     * Get a specific memory by ID
+     */
+    get(id: string): Promise<MemoryResponse>;
+    /**
+     * Update a memory (partial update using PATCH)
+     */
+    update(id: string, patch: Partial<UpdateMemoryInput>): Promise<MemoryResponse>;
+    /**
+     * Replace a memory (full update using PUT)
+     */
+    put(id: string, body: PutMemoryInput): Promise<MemoryResponse>;
+    /**
+     * Delete a memory
+     */
+    delete(id: string): Promise<DeleteResponse>;
+    /**
+     * Search memories using semantic search or filters
+     */
+    search(params: SearchParams): Promise<SearchResponse>;
+    /**
+     * Execute batch operations atomically
+     */
+    batch(body: BatchRequest): Promise<BatchResponse>;
+}
+/**
+ * Threads namespace for all thread-related operations
+ */
+declare class ThreadsNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new thread
+     */
+    create(input?: CreateThreadInput): Promise<Thread>;
+    /**
+     * List threads with pagination
+     */
+    list(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ThreadListResponse>;
+    /**
+     * Get a thread by ID, optionally with memories
+     */
+    get(id: string, options?: {
+        includeMemories?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<Thread | ThreadWithMemories>;
+    /**
+     * Update a thread
+     */
+    update(id: string, input: UpdateThreadInput): Promise<Thread>;
+    /**
+     * Delete a thread (memories are unlinked, not deleted)
+     */
+    delete(id: string): Promise<{
+        ok: boolean;
+        unlinked_memories?: number;
+    }>;
+    /**
+     * Link a memory to a thread
+     */
+    linkMemory(threadId: string, memoryId: string): Promise<LinkMemoryResponse>;
+}
+/**
+ * Chat namespace for session and messaging operations
+ */
+declare class ChatNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Create a new chat session
+     */
+    createSession(input?: CreateSessionInput): Promise<Session>;
+    /**
+     * Get a chat session by ID
+     */
+    getSession(sessionId: string): Promise<Session>;
+    /**
+     * List chat sessions
+     */
+    listSessions(params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Session[]>;
+    /**
+     * Get messages for a session
+     */
+    getMessages(sessionId: string, limit?: number): Promise<Message[]>;
+    /**
+     * Send a message with SSE streaming
+     */
+    sendMessage(sessionId: string, message: string | SendMessageOptions, opts?: SendMessageOptions): AsyncGenerator<StreamEvent, void, unknown>;
+}
+/**
+ * Keys namespace for API key management
+ */
+declare class KeysNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List API keys
+     */
+    list(): Promise<ApiKey[]>;
+    /**
+     * Create a new API key
+     */
+    create(name: string): Promise<ApiKey>;
+    /**
+     * Update an API key
+     */
+    update(id: string, patch: UpdateKeyInput): Promise<ApiKey>;
+    /**
+     * Revoke an API key
+     */
+    revoke(id: string): Promise<void>;
+}
+/**
+ * Recall namespace for profile extraction and facts
+ */
+declare class RecallNamespace {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * Extract profile entity from text (client-side)
+     */
+    extractProfile(text: string): ProfileExtraction;
+    /**
+     * Get profile facts from memories
+     */
+    getProfileFacts(): Promise<ProfileFacts>;
+    /**
+     * Save a profile fact in canonical form
+     */
+    saveProfileFact(kind: ProfileEntity, value: string): Promise<MemoryResponse>;
 }
-//# sourceMappingURL=index.d.ts.map
+
+export { type ApiKey, type BatchOp, type BatchRequest, type BatchResponse, type BatchResult, type CreateMemoryInput, type CreateResponse, type CreateSessionInput, type CreateThreadInput, type DeleteResponse, type LinkMemoryResponse, type ListParams, type ListResponse, type MemoryResponse, type MemoryType, type Message, NetworkError, type ProfileEntity, type ProfileExtraction, type ProfileFacts, type PutMemoryInput, type SearchHit, type SearchParams, type SearchResponse, type SendMessageOptions, type Session, Sovant, type SovantConfig, SovantError, type StreamEvent, type Thread, type ThreadListResponse, type ThreadWithMemories, TimeoutError, type UpdateKeyInput, type UpdateMemoryInput, type UpdateThreadInput, Sovant as default };