@memorylayerai/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,492 @@
+/**
+ * Configuration options for the MemoryLayer client
+ */
+interface ClientConfig$1 {
+    /** API key for authentication (can also be set via MEMORYLAYER_API_KEY env var) */
+    apiKey?: string;
+    /** Base URL for the API (default: https://api.memorylayer.com) */
+    baseURL?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial retry delay in milliseconds (default: 1000) */
+    retryDelay?: number;
+    /** Custom headers to include in all requests */
+    headers?: Record<string, string>;
+    /** Logger for debugging */
+    logger?: {
+        debug(message: string, ...args: any[]): void;
+        info(message: string, ...args: any[]): void;
+        warn(message: string, ...args: any[]): void;
+        error(message: string, ...args: any[]): void;
+    };
+}
+/**
+ * Main MemoryLayer SDK client
+ */
+declare class MemoryLayerClient {
+    private httpClient;
+    private _memories?;
+    private _search?;
+    private _ingest?;
+    private _router?;
+    constructor(config?: ClientConfig$1);
+    /**
+     * Access memory operations
+     */
+    get memories(): any;
+    /**
+     * Access search operations
+     */
+    get search(): any;
+    /**
+     * Access ingestion operations
+     */
+    get ingest(): any;
+    /**
+     * Access router operations
+     */
+    get router(): any;
+}
+
+/**
+ * Base error class for all MemoryLayer SDK errors
+ */
+declare class MemoryLayerError extends Error {
+    statusCode?: number | undefined;
+    requestId?: string | undefined;
+    details?: any | undefined;
+    constructor(message: string, statusCode?: number | undefined, requestId?: string | undefined, details?: any | undefined);
+}
+/**
+ * Error thrown when authentication fails (401)
+ */
+declare class AuthenticationError extends MemoryLayerError {
+    constructor(message: string, requestId?: string);
+}
+/**
+ * Error thrown when rate limit is exceeded (429)
+ */
+declare class RateLimitError extends MemoryLayerError {
+    retryAfter: number;
+    constructor(message: string, retryAfter: number, requestId?: string);
+}
+/**
+ * Validation error detail
+ */
+interface ValidationErrorDetail {
+    field: string;
+    message: string;
+}
+/**
+ * Error thrown when request validation fails (400)
+ */
+declare class ValidationError extends MemoryLayerError {
+    errors: ValidationErrorDetail[];
+    constructor(message: string, errors: ValidationErrorDetail[], requestId?: string);
+}
+/**
+ * Error thrown when network request fails
+ */
+declare class NetworkError extends MemoryLayerError {
+    cause: Error;
+    constructor(message: string, cause: Error);
+}
+/**
+ * Error thrown for other API errors
+ */
+declare class APIError extends MemoryLayerError {
+    constructor(message: string, statusCode: number, requestId?: string, details?: any);
+}
+
+/**
+ * Memory object
+ */
+interface Memory {
+    /** Unique identifier for the memory */
+    id: string;
+    /** Content of the memory */
+    content: string;
+    /** Optional metadata associated with the memory */
+    metadata?: Record<string, any>;
+    /** Project ID this memory belongs to */
+    projectId: string;
+    /** Timestamp when the memory was created */
+    createdAt: string;
+    /** Timestamp when the memory was last updated */
+    updatedAt: string;
+}
+/**
+ * Request to create a new memory
+ */
+interface CreateMemoryRequest {
+    /** Content of the memory */
+    content: string;
+    /** Optional metadata to associate with the memory */
+    metadata?: Record<string, any>;
+    /** Project ID to create the memory in */
+    projectId: string;
+}
+/**
+ * Request to update an existing memory
+ */
+interface UpdateMemoryRequest {
+    /** New content for the memory (optional) */
+    content?: string;
+    /** New metadata for the memory (optional) */
+    metadata?: Record<string, any>;
+}
+/**
+ * Request to list memories
+ */
+interface ListMemoriesRequest {
+    /** Project ID to list memories from */
+    projectId: string;
+    /** Maximum number of memories to return (default: 100) */
+    limit?: number;
+    /** Number of memories to skip (default: 0) */
+    offset?: number;
+    /** Filter criteria for memories */
+    filter?: Record<string, any>;
+}
+/**
+ * Search request
+ */
+interface SearchRequest {
+    /** Search query */
+    query: string;
+    /** Project ID to search in */
+    projectId: string;
+    /** Maximum number of results to return (default: 10) */
+    limit?: number;
+    /** Filter criteria for search */
+    filter?: Record<string, any>;
+    /** Minimum relevance score threshold (0-1) */
+    threshold?: number;
+}
+/**
+ * Search result
+ */
+interface SearchResult {
+    /** The memory that matched the search */
+    memory: Memory;
+    /** Relevance score (0-1) */
+    score: number;
+    /** Highlighted text snippets */
+    highlights?: string[];
+}
+/**
+ * Search response
+ */
+interface SearchResponse {
+    /** Array of search results */
+    results: SearchResult[];
+    /** Total number of results found */
+    total: number;
+}
+/**
+ * Request to ingest a file
+ */
+interface IngestFileRequest {
+    /** File to ingest (Buffer, Blob, or File) */
+    file: Buffer | Blob | File;
+    /** Project ID to ingest into */
+    projectId: string;
+    /** Optional metadata to associate with ingested memories */
+    metadata?: Record<string, any>;
+    /** Chunk size for splitting the file (default: 1000) */
+    chunkSize?: number;
+    /** Overlap between chunks (default: 200) */
+    chunkOverlap?: number;
+}
+/**
+ * Request to ingest text
+ */
+interface IngestTextRequest {
+    /** Text to ingest */
+    text: string;
+    /** Project ID to ingest into */
+    projectId: string;
+    /** Optional metadata to associate with ingested memories */
+    metadata?: Record<string, any>;
+    /** Chunk size for splitting the text (default: 1000) */
+    chunkSize?: number;
+    /** Overlap between chunks (default: 200) */
+    chunkOverlap?: number;
+}
+/**
+ * Ingestion response
+ */
+interface IngestResponse {
+    /** IDs of the created memories */
+    memoryIds: string[];
+    /** Number of chunks created */
+    chunksCreated: number;
+}
+/**
+ * Message in a conversation
+ */
+interface Message {
+    /** Role of the message sender */
+    role: 'user' | 'assistant' | 'system';
+    /** Content of the message */
+    content: string;
+}
+/**
+ * Router request
+ */
+interface RouterRequest {
+    /** Array of messages in the conversation */
+    messages: Message[];
+    /** Project ID for memory context */
+    projectId: string;
+    /** Model to use (optional) */
+    model?: string;
+    /** Temperature for generation (0-2, default: 1) */
+    temperature?: number;
+    /** Maximum tokens to generate */
+    maxTokens?: number;
+    /** Whether to stream the response */
+    stream?: boolean;
+}
+/**
+ * Token usage information
+ */
+interface Usage {
+    /** Number of tokens in the prompt */
+    promptTokens: number;
+    /** Number of tokens in the completion */
+    completionTokens: number;
+    /** Total number of tokens used */
+    totalTokens: number;
+}
+/**
+ * Choice in a router response
+ */
+interface Choice {
+    /** The generated message */
+    message: Message;
+    /** Reason why generation finished */
+    finishReason: string;
+}
+/**
+ * Router response
+ */
+interface RouterResponse {
+    /** Unique identifier for the response */
+    id: string;
+    /** Array of choices (usually one) */
+    choices: Choice[];
+    /** Token usage information */
+    usage: Usage;
+}
+/**
+ * Delta in a streaming choice
+ */
+interface StreamDelta {
+    /** Role of the message (only in first chunk) */
+    role?: string;
+    /** Content chunk */
+    content?: string;
+}
+/**
+ * Choice in a streaming response
+ */
+interface StreamChoice {
+    /** Delta containing the new content */
+    delta: StreamDelta;
+    /** Reason why generation finished (only in last chunk) */
+    finishReason?: string;
+}
+/**
+ * Streaming chunk from router
+ */
+interface StreamChunk {
+    /** Unique identifier for the response */
+    id: string;
+    /** Array of streaming choices */
+    choices: StreamChoice[];
+}
+
+/**
+ * Configuration for the HTTP client
+ */
+interface ClientConfig {
+    apiKey: string;
+    baseURL?: string;
+    timeout?: number;
+    maxRetries?: number;
+    retryDelay?: number;
+    headers?: Record<string, string>;
+    logger?: Logger;
+}
+/**
+ * Logger interface
+ */
+interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+/**
+ * Retry configuration
+ */
+interface RetryConfig {
+    maxRetries: number;
+    initialDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+    retryableStatusCodes: number[];
+}
+/**
+ * Request options
+ */
+interface RequestOptions {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    body?: any;
+    query?: Record<string, string>;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+/**
+ * HTTP client with retry logic and error handling
+ */
+declare class HTTPClient {
+    private config;
+    private retryConfig;
+    private baseURL;
+    constructor(config: ClientConfig, retryConfig?: Partial<RetryConfig>);
+    /**
+     * Make an HTTP request with retry logic
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+    /**
+     * Make a streaming request
+     */
+    stream(options: RequestOptions): AsyncIterable<any>;
+    /**
+     * Make the actual HTTP request
+     */
+    private makeRequest;
+    /**
+     * Build the full URL with query parameters
+     */
+    private buildURL;
+    /**
+     * Build request headers
+     */
+    private buildHeaders;
+    /**
+     * Handle error responses from the API
+     */
+    private handleErrorResponse;
+    /**
+     * Determine if an error should be retried
+     */
+    private shouldRetry;
+    /**
+     * Calculate retry delay with exponential backoff
+     */
+    private getRetryDelay;
+    /**
+     * Sleep for a specified duration
+     */
+    private sleep;
+}
+
+/**
+ * Resource for memory operations
+ */
+declare class MemoriesResource {
+    private httpClient;
+    constructor(httpClient: HTTPClient);
+    /**
+     * Add a new memory
+     * @param request - Memory creation request
+     * @returns The created memory
+     */
+    add(request: CreateMemoryRequest): Promise<Memory>;
+    /**
+     * Get a memory by ID
+     * @param id - Memory ID
+     * @returns The memory
+     */
+    get(id: string): Promise<Memory>;
+    /**
+     * Update a memory
+     * @param id - Memory ID
+     * @param request - Update request
+     * @returns The updated memory
+     */
+    update(id: string, request: UpdateMemoryRequest): Promise<Memory>;
+    /**
+     * Delete a memory
+     * @param id - Memory ID
+     */
+    delete(id: string): Promise<void>;
+    /**
+     * List memories
+     * @param request - List request with filters
+     * @returns Array of memories
+     */
+    list(request: ListMemoriesRequest): Promise<Memory[]>;
+}
+
+/**
+ * Resource for search operations
+ */
+declare class SearchResource {
+    private httpClient;
+    constructor(httpClient: HTTPClient);
+    /**
+     * Search memories
+     * @param request - Search request
+     * @returns Search results
+     */
+    search(request: SearchRequest): Promise<SearchResponse>;
+}
+
+/**
+ * Resource for ingestion operations
+ */
+declare class IngestResource {
+    private httpClient;
+    constructor(httpClient: HTTPClient);
+    /**
+     * Ingest a file
+     * @param request - File ingestion request
+     * @returns Ingestion response with created memory IDs
+     */
+    file(request: IngestFileRequest): Promise<IngestResponse>;
+    /**
+     * Ingest text
+     * @param request - Text ingestion request
+     * @returns Ingestion response with created memory IDs
+     */
+    text(request: IngestTextRequest): Promise<IngestResponse>;
+}
+
+/**
+ * Resource for router operations
+ */
+declare class RouterResource {
+    private httpClient;
+    constructor(httpClient: HTTPClient);
+    /**
+     * Complete a router request (non-streaming)
+     * @param request - Router request
+     * @returns Router response
+     */
+    complete(request: RouterRequest): Promise<RouterResponse>;
+    /**
+     * Stream a router request
+     * @param request - Router request
+     * @returns Async iterable of stream chunks
+     */
+    stream(request: RouterRequest): AsyncIterable<StreamChunk>;
+}
+
+export { APIError, AuthenticationError, type Choice, type ClientConfig$1 as ClientConfig, type CreateMemoryRequest, type IngestFileRequest, IngestResource, type IngestResponse, type IngestTextRequest, type ListMemoriesRequest, MemoriesResource, type Memory, MemoryLayerClient, MemoryLayerError, type Message, NetworkError, RateLimitError, type RouterRequest, RouterResource, type RouterResponse, type SearchRequest, SearchResource, type SearchResponse, type SearchResult, type StreamChoice, type StreamChunk, type StreamDelta, type UpdateMemoryRequest, type Usage, ValidationError, type ValidationErrorDetail };