@zibby/mem0ai 2.4.7

package/README.md

@@ -0,0 +1,64 @@
+# Mem0 - The Memory Layer for Your AI Apps
+
+Mem0 is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. We offer both cloud and open-source solutions to cater to different needs.
+
+See the complete [OSS Docs](https://docs.mem0.ai/open-source/node-quickstart).
+See the complete [Platform API Reference](https://docs.mem0.ai/api-reference).
+
+## 1. Installation
+
+For the open-source version, you can install the Mem0 package using npm:
+
+```bash
+npm i mem0ai
+```
+
+## 2. API Key Setup
+
+For the cloud offering, sign in to [Mem0 Platform](https://app.mem0.ai/dashboard/api-keys) to obtain your API Key.
+
+## 3. Client Features
+
+### Cloud Offering
+
+The cloud version provides a comprehensive set of features, including:
+
+- **Memory Operations**: Perform CRUD operations on memories.
+- **Search Capabilities**: Search for relevant memories using advanced filters.
+- **Memory History**: Track changes to memories over time.
+- **Error Handling**: Robust error handling for API-related issues.
+- **Async/Await Support**: All methods return promises for easy integration.
+
+### Open-Source Offering
+
+The open-source version includes the following top features:
+
+- **Memory Management**: Add, update, delete, and retrieve memories.
+- **Vector Store Integration**: Supports various vector store providers for efficient memory retrieval.
+- **LLM Support**: Integrates with multiple LLM providers for generating responses.
+- **Customizable Configuration**: Easily configure memory settings and providers.
+- **SQLite Storage**: Use SQLite for memory history management.
+
+## 4. Memory Operations
+
+Mem0 provides a simple and customizable interface for performing memory operations. You can create long-term and short-term memories, search for relevant memories, and manage memory history.
+
+## 5. Error Handling
+
+The MemoryClient throws errors for any API-related issues. You can catch and handle these errors effectively.
+
+## 6. Using with async/await
+
+All methods of the MemoryClient return promises, allowing for seamless integration with async/await syntax.
+
+## 7. Testing the Client
+
+To test the MemoryClient in a Node.js environment, you can create a simple script to verify the functionality of memory operations.
+
+## Getting Help
+
+If you have any questions or need assistance, please reach out to us:
+
+- Email: founders@mem0.ai
+- [Join our discord community](https://mem0.ai/discord)
+- GitHub Issues: [Report bugs or request features](https://github.com/mem0ai/mem0/issues)

package/dist/index.d.mts

@@ -0,0 +1,364 @@
+interface Common {
+    project_id?: string | null;
+    org_id?: string | null;
+}
+interface MemoryOptions {
+    api_version?: API_VERSION | string;
+    version?: API_VERSION | string;
+    user_id?: string;
+    agent_id?: string;
+    app_id?: string;
+    run_id?: string;
+    metadata?: Record<string, any>;
+    filters?: Record<string, any>;
+    org_name?: string | null;
+    project_name?: string | null;
+    org_id?: string | number | null;
+    project_id?: string | number | null;
+    infer?: boolean;
+    page?: number;
+    page_size?: number;
+    includes?: string;
+    excludes?: string;
+    enable_graph?: boolean;
+    start_date?: string;
+    end_date?: string;
+    custom_categories?: custom_categories[];
+    custom_instructions?: string;
+    timestamp?: number;
+    output_format?: string | OutputFormat;
+    async_mode?: boolean;
+    filter_memories?: boolean;
+    immutable?: boolean;
+    structured_data_schema?: Record<string, any>;
+}
+interface ProjectOptions {
+    fields?: string[];
+}
+declare enum OutputFormat {
+    V1 = "v1.0",
+    V1_1 = "v1.1"
+}
+declare enum API_VERSION {
+    V1 = "v1",
+    V2 = "v2"
+}
+declare enum Feedback {
+    POSITIVE = "POSITIVE",
+    NEGATIVE = "NEGATIVE",
+    VERY_NEGATIVE = "VERY_NEGATIVE"
+}
+interface MultiModalMessages {
+    type: "image_url";
+    image_url: {
+        url: string;
+    };
+}
+interface Messages {
+    role: "user" | "assistant";
+    content: string | MultiModalMessages;
+}
+interface Message extends Messages {
+}
+interface MemoryHistory {
+    id: string;
+    memory_id: string;
+    input: Array<Messages>;
+    old_memory: string | null;
+    new_memory: string | null;
+    user_id: string;
+    categories: Array<string>;
+    event: Event | string;
+    created_at: Date;
+    updated_at: Date;
+}
+interface SearchOptions extends MemoryOptions {
+    api_version?: API_VERSION | string;
+    limit?: number;
+    enable_graph?: boolean;
+    threshold?: number;
+    top_k?: number;
+    only_metadata_based_search?: boolean;
+    keyword_search?: boolean;
+    fields?: string[];
+    categories?: string[];
+    rerank?: boolean;
+}
+declare enum Event {
+    ADD = "ADD",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    NOOP = "NOOP"
+}
+interface MemoryData {
+    memory: string;
+}
+interface Memory {
+    id: string;
+    messages?: Array<Messages>;
+    event?: Event | string;
+    data?: MemoryData | null;
+    memory?: string;
+    user_id?: string;
+    hash?: string;
+    categories?: Array<string>;
+    created_at?: Date;
+    updated_at?: Date;
+    memory_type?: string;
+    score?: number;
+    metadata?: any | null;
+    owner?: string | null;
+    agent_id?: string | null;
+    app_id?: string | null;
+    run_id?: string | null;
+}
+interface MemoryUpdateBody {
+    memoryId: string;
+    text: string;
+}
+interface User {
+    id: string;
+    name: string;
+    created_at: Date;
+    updated_at: Date;
+    total_memories: number;
+    owner: string;
+    type: string;
+}
+interface AllUsers {
+    count: number;
+    results: Array<User>;
+    next: any;
+    previous: any;
+}
+interface ProjectResponse {
+    custom_instructions?: string;
+    custom_categories?: string[];
+    [key: string]: any;
+}
+interface custom_categories {
+    [key: string]: any;
+}
+interface PromptUpdatePayload {
+    custom_instructions?: string;
+    custom_categories?: custom_categories[];
+    retrieval_criteria?: any[];
+    enable_graph?: boolean;
+    version?: string;
+    inclusion_prompt?: string;
+    exclusion_prompt?: string;
+    memory_depth?: string | null;
+    usecase_setting?: string | number;
+    multilingual?: boolean;
+    [key: string]: any;
+}
+declare enum WebhookEvent {
+    MEMORY_ADDED = "memory_add",
+    MEMORY_UPDATED = "memory_update",
+    MEMORY_DELETED = "memory_delete",
+    MEMORY_CATEGORIZED = "memory_categorize"
+}
+interface Webhook {
+    webhook_id?: string;
+    name: string;
+    url: string;
+    project?: string;
+    created_at?: Date;
+    updated_at?: Date;
+    is_active?: boolean;
+    event_types?: WebhookEvent[];
+}
+interface WebhookCreatePayload {
+    name: string;
+    url: string;
+    eventTypes: WebhookEvent[];
+}
+interface WebhookUpdatePayload {
+    webhookId: string;
+    name?: string;
+    url?: string;
+    eventTypes?: WebhookEvent[];
+}
+interface FeedbackPayload {
+    memory_id: string;
+    feedback?: Feedback | null;
+    feedback_reason?: string | null;
+}
+interface CreateMemoryExportPayload extends Common {
+    schema: Record<string, any>;
+    filters: Record<string, any>;
+    export_instructions?: string;
+}
+interface GetMemoryExportPayload extends Common {
+    filters?: Record<string, any>;
+    memory_export_id?: string;
+}
+
+interface ClientOptions {
+    apiKey: string;
+    host?: string;
+    organizationName?: string;
+    projectName?: string;
+    organizationId?: string;
+    projectId?: string;
+}
+declare class MemoryClient {
+    apiKey: string;
+    host: string;
+    organizationName: string | null;
+    projectName: string | null;
+    organizationId: string | number | null;
+    projectId: string | number | null;
+    headers: Record<string, string>;
+    client: any;
+    telemetryId: string;
+    _validateApiKey(): any;
+    _validateOrgProject(): void;
+    constructor(options: ClientOptions);
+    private _initializeClient;
+    private _captureEvent;
+    _fetchWithErrorHandling(url: string, options: any): Promise<any>;
+    _preparePayload(messages: Array<Message>, options: MemoryOptions): object;
+    _prepareParams(options: MemoryOptions): object;
+    ping(): Promise<void>;
+    add(messages: Array<Message>, options?: MemoryOptions & Record<string, any>): Promise<Array<Memory>>;
+    update(memoryId: string, { text, metadata, timestamp, }: {
+        text?: string;
+        metadata?: Record<string, any>;
+        timestamp?: number | string;
+    }): Promise<Array<Memory>>;
+    get(memoryId: string): Promise<Memory>;
+    getAll(options?: SearchOptions): Promise<Array<Memory>>;
+    search(query: string, options?: SearchOptions & Record<string, any>): Promise<Array<Memory>>;
+    delete(memoryId: string): Promise<{
+        message: string;
+    }>;
+    deleteAll(options?: MemoryOptions): Promise<{
+        message: string;
+    }>;
+    history(memoryId: string): Promise<Array<MemoryHistory>>;
+    users(): Promise<AllUsers>;
+    /**
+     * @deprecated The method should not be used, use `deleteUsers` instead. This will be removed in version 2.2.0.
+     */
+    deleteUser(data: {
+        entity_id: number;
+        entity_type: string;
+    }): Promise<{
+        message: string;
+    }>;
+    deleteUsers(params?: {
+        user_id?: string;
+        agent_id?: string;
+        app_id?: string;
+        run_id?: string;
+    }): Promise<{
+        message: string;
+    }>;
+    batchUpdate(memories: Array<MemoryUpdateBody>): Promise<string>;
+    batchDelete(memories: Array<string>): Promise<string>;
+    getProject(options: ProjectOptions): Promise<ProjectResponse>;
+    updateProject(prompts: PromptUpdatePayload): Promise<Record<string, any>>;
+    getWebhooks(data?: {
+        projectId?: string;
+    }): Promise<Array<Webhook>>;
+    createWebhook(webhook: WebhookCreatePayload): Promise<Webhook>;
+    updateWebhook(webhook: WebhookUpdatePayload): Promise<{
+        message: string;
+    }>;
+    deleteWebhook(data: {
+        webhookId: string;
+    }): Promise<{
+        message: string;
+    }>;
+    feedback(data: FeedbackPayload): Promise<{
+        message: string;
+    }>;
+    createMemoryExport(data: CreateMemoryExportPayload): Promise<{
+        message: string;
+        id: string;
+    }>;
+    getMemoryExport(data: GetMemoryExportPayload): Promise<{
+        message: string;
+        id: string;
+    }>;
+}
+
+/**
+ * Structured exception classes for mem0 TypeScript SDK.
+ *
+ * Provides specific, actionable exceptions with error codes, suggestions,
+ * and debug information. Maps HTTP status codes to appropriate exception types.
+ *
+ * @example
+ * ```typescript
+ * import { RateLimitError, MemoryNotFoundError } from 'mem0ai'
+ *
+ * try {
+ *   await client.get(memoryId)
+ * } catch (e) {
+ *   if (e instanceof MemoryNotFoundError) {
+ *     console.log(e.suggestion) // "The requested resource was not found"
+ *   } else if (e instanceof RateLimitError) {
+ *     await sleep(e.debugInfo.retryAfter ?? 60)
+ *   }
+ * }
+ * ```
+ */
+interface MemoryErrorOptions {
+    details?: Record<string, unknown>;
+    suggestion?: string;
+    debugInfo?: Record<string, unknown>;
+}
+/**
+ * Base exception for all memory-related errors.
+ *
+ * Every mem0 exception includes an error code for programmatic handling,
+ * optional details, a user-friendly suggestion, and debug information.
+ */
+declare class MemoryError extends Error {
+    readonly errorCode: string;
+    readonly details: Record<string, unknown>;
+    readonly suggestion?: string;
+    readonly debugInfo: Record<string, unknown>;
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when authentication fails (401, 403). */
+declare class AuthenticationError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when rate limits are exceeded (429). */
+declare class RateLimitError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when input validation fails (400, 409, 422). */
+declare class ValidationError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when a memory is not found (404). */
+declare class MemoryNotFoundError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when network connectivity issues occur (408, 502, 503, 504). */
+declare class NetworkError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when client configuration is invalid. */
+declare class ConfigurationError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/** Raised when memory quota is exceeded (413). */
+declare class MemoryQuotaExceededError extends MemoryError {
+    constructor(message: string, errorCode: string, options?: MemoryErrorOptions);
+}
+/**
+ * Create an appropriate exception based on HTTP response status code.
+ *
+ * @param statusCode - HTTP status code from the response
+ * @param responseText - Response body text
+ * @param options - Additional error context (details, debugInfo)
+ * @returns An instance of the appropriate MemoryError subclass
+ */
+declare function createExceptionFromResponse(statusCode: number, responseText: string, options?: Omit<MemoryErrorOptions, "suggestion">): MemoryError;
+
+export { type AllUsers, AuthenticationError, ConfigurationError, Feedback, type FeedbackPayload, type Memory, MemoryClient, MemoryError, type MemoryErrorOptions, type MemoryHistory, MemoryNotFoundError, type MemoryOptions, MemoryQuotaExceededError, type MemoryUpdateBody, type Message, type Messages, NetworkError, type ProjectOptions, type ProjectResponse, type PromptUpdatePayload, RateLimitError, type SearchOptions, type User, ValidationError, type Webhook, type WebhookCreatePayload, WebhookEvent, type WebhookUpdatePayload, createExceptionFromResponse, MemoryClient as default };