@positronic/mem0 0.0.57

package/dist/src/provider.js

@@ -0,0 +1,271 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Creates a Mem0 memory provider.
+ *
+ * @param config - Configuration for the Mem0 provider
+ * @returns A MemoryProvider implementation
+ *
+ * @example
+ * ```typescript
+ * const memory = createMem0Provider({
+ *   apiKey: process.env.MEM0_API_KEY!,
+ *   projectId: 'my-project',
+ * });
+ *
+ * const myBrain = brain('my-brain')
+ *   .withMemory(memory)
+ *   .brain('agent', async ({ memory }) => {
+ *     const prefs = await memory.search('user preferences');
+ *     return { system: `Preferences: ${prefs}`, prompt: 'Help' };
+ *   });
+ * ```
+ */ export function createMem0Provider(config) {
+    var apiKey = config.apiKey, _config_baseUrl = config.baseUrl, baseUrl = _config_baseUrl === void 0 ? 'https://api.mem0.ai/v1' : _config_baseUrl, orgId = config.orgId, projectId = config.projectId;
+    var headers = {
+        'Content-Type': 'application/json',
+        Authorization: "Token ".concat(apiKey)
+    };
+    if (orgId) {
+        headers['Mem0-Org-Id'] = orgId;
+    }
+    if (projectId) {
+        headers['Mem0-Project-Id'] = projectId;
+    }
+    return {
+        search: function search(query, scope, options) {
+            return _async_to_generator(function() {
+                var body, response, errorText, data;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            body = {
+                                query: query,
+                                agent_id: scope.agentId
+                            };
+                            if (scope.userId) {
+                                body.user_id = scope.userId;
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.limit) {
+                                body.limit = options.limit;
+                            }
+                            return [
+                                4,
+                                fetch("".concat(baseUrl, "/memories/search/"), {
+                                    method: 'POST',
+                                    headers: headers,
+                                    body: JSON.stringify(body)
+                                })
+                            ];
+                        case 1:
+                            response = _state.sent();
+                            if (!!response.ok) return [
+                                3,
+                                3
+                            ];
+                            return [
+                                4,
+                                response.text()
+                            ];
+                        case 2:
+                            errorText = _state.sent();
+                            throw new Error("Mem0 search failed (".concat(response.status, "): ").concat(errorText));
+                        case 3:
+                            return [
+                                4,
+                                response.json()
+                            ];
+                        case 4:
+                            data = _state.sent();
+                            return [
+                                2,
+                                data.map(function(result) {
+                                    return {
+                                        id: result.id,
+                                        content: result.memory,
+                                        score: result.score,
+                                        metadata: result.metadata
+                                    };
+                                })
+                            ];
+                    }
+                });
+            })();
+        },
+        add: function add(messages, scope, options) {
+            return _async_to_generator(function() {
+                var body, response, errorText;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            body = {
+                                messages: messages.map(function(m) {
+                                    return {
+                                        role: m.role,
+                                        content: m.content
+                                    };
+                                }),
+                                agent_id: scope.agentId
+                            };
+                            if (scope.userId) {
+                                body.user_id = scope.userId;
+                            }
+                            if (options === null || options === void 0 ? void 0 : options.metadata) {
+                                body.metadata = options.metadata;
+                            }
+                            return [
+                                4,
+                                fetch("".concat(baseUrl, "/memories/"), {
+                                    method: 'POST',
+                                    headers: headers,
+                                    body: JSON.stringify(body)
+                                })
+                            ];
+                        case 1:
+                            response = _state.sent();
+                            if (!!response.ok) return [
+                                3,
+                                3
+                            ];
+                            return [
+                                4,
+                                response.text()
+                            ];
+                        case 2:
+                            errorText = _state.sent();
+                            throw new Error("Mem0 add failed (".concat(response.status, "): ").concat(errorText));
+                        case 3:
+                            // We don't need to process the response, just ensure it succeeded
+                            return [
+                                4,
+                                response.json()
+                            ];
+                        case 4:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}

package/dist/src/tools.js

@@ -0,0 +1,284 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { z } from 'zod';
+/**
+ * Schema for the rememberFact tool input
+ */ var rememberFactSchema = z.object({
+    fact: z.string().describe('The fact or information to remember for later'),
+    userId: z.string().optional().describe('Optional user ID to associate this memory with')
+});
+/**
+ * Schema for the recallMemories tool input
+ */ var recallMemoriesSchema = z.object({
+    query: z.string().describe('The search query to find relevant memories'),
+    userId: z.string().optional().describe('Optional user ID to scope the search'),
+    limit: z.number().optional().default(10).describe('Maximum number of memories to return')
+});
+/**
+ * Tool for storing facts in long-term memory.
+ *
+ * This tool allows the agent to store important information for future reference.
+ * Facts are stored with the agent's scope and optionally a user ID.
+ *
+ * @example
+ * ```typescript
+ * const tools = createMem0Tools();
+ *
+ * const myBrain = brain('my-brain')
+ *   .withMemory(memory)
+ *   .brain('agent', ({ tools: defaultTools }) => ({
+ *     system: 'You are helpful. Store user preferences with rememberFact.',
+ *     prompt: 'User says: I prefer dark mode',
+ *     tools: { ...defaultTools, ...tools },
+ *   }));
+ * ```
+ */ export var rememberFact = {
+    description: 'Store a fact or piece of information in long-term memory for future reference.\n\nUse this tool when:\n- The user shares a preference (e.g., "I like dark mode", "I prefer brief responses")\n- The user provides important context (e.g., "I\'m working on project X", "I\'m a beginner")\n- You learn something that should persist across conversations\n\nThe fact should be a clear, standalone statement that can be retrieved later.',
+    inputSchema: rememberFactSchema,
+    execute: function execute(input, context) {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!context.memory) {
+                            return [
+                                2,
+                                {
+                                    remembered: false,
+                                    fact: input.fact
+                                }
+                            ];
+                        }
+                        return [
+                            4,
+                            context.memory.add([
+                                {
+                                    role: 'assistant',
+                                    content: input.fact
+                                }
+                            ], {
+                                userId: input.userId
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            {
+                                remembered: true,
+                                fact: input.fact
+                            }
+                        ];
+                }
+            });
+        })();
+    }
+};
+/**
+ * Tool for recalling memories from long-term storage.
+ *
+ * This tool allows the agent to search for and retrieve relevant memories.
+ * Memories are searched within the agent's scope and optionally a user ID.
+ *
+ * @example
+ * ```typescript
+ * const tools = createMem0Tools();
+ *
+ * const myBrain = brain('my-brain')
+ *   .withMemory(memory)
+ *   .brain('agent', ({ tools: defaultTools }) => ({
+ *     system: 'Use recallMemories to find relevant user preferences.',
+ *     prompt: 'What theme does the user prefer?',
+ *     tools: { ...defaultTools, ...tools },
+ *   }));
+ * ```
+ */ export var recallMemories = {
+    description: "Search long-term memory for relevant information.\n\nUse this tool to retrieve:\n- User preferences and settings\n- Previous context or decisions\n- Facts learned in earlier interactions\n\nThe query should describe what you're looking for. Results include relevance scores.",
+    inputSchema: recallMemoriesSchema,
+    execute: function execute(input, context) {
+        return _async_to_generator(function() {
+            var memories;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!context.memory) {
+                            return [
+                                2,
+                                {
+                                    found: 0,
+                                    memories: []
+                                }
+                            ];
+                        }
+                        return [
+                            4,
+                            context.memory.search(input.query, {
+                                userId: input.userId,
+                                limit: input.limit
+                            })
+                        ];
+                    case 1:
+                        memories = _state.sent();
+                        return [
+                            2,
+                            {
+                                found: memories.length,
+                                memories: memories.map(function(m) {
+                                    return {
+                                        content: m.content,
+                                        relevance: m.score
+                                    };
+                                })
+                            }
+                        ];
+                }
+            });
+        })();
+    }
+};
+/**
+ * Creates the standard Mem0 memory tools.
+ *
+ * Returns an object with `rememberFact` and `recallMemories` tools
+ * that can be spread into your agent's tools configuration.
+ *
+ * @returns Object containing memory tools
+ *
+ * @example
+ * ```typescript
+ * import { createMem0Tools } from '@positronic/mem0';
+ *
+ * const memoryTools = createMem0Tools();
+ *
+ * const myBrain = brain('my-brain')
+ *   .withMemory(provider)
+ *   .brain('agent', () => ({
+ *     system: 'You can remember and recall information.',
+ *     prompt: 'Help the user',
+ *     tools: memoryTools,
+ *   }));
+ * ```
+ */ export function createMem0Tools() {
+    return {
+        rememberFact: rememberFact,
+        recallMemories: recallMemories
+    };
+}

package/dist/types/adapter.d.ts

@@ -0,0 +1,41 @@
+import type { Adapter, MemoryProvider } from '@positronic/core';
+/**
+ * Configuration for the Mem0 adapter.
+ */
+export interface Mem0AdapterConfig {
+    /** The memory provider to use for storing conversations */
+    provider: MemoryProvider;
+    /**
+     * Whether to include tool calls in the conversation history.
+     * Defaults to false.
+     */
+    includeToolCalls?: boolean;
+}
+/**
+ * Creates a Mem0 adapter that automatically indexes conversations to memory.
+ *
+ * The adapter listens to brain events and buffers messages from agent steps.
+ * When the brain completes or encounters an error, it flushes the buffered
+ * messages to the memory provider.
+ *
+ * @param config - Configuration for the adapter
+ * @returns An Adapter implementation
+ *
+ * @example
+ * ```typescript
+ * import { createMem0Adapter, createMem0Provider } from '@positronic/mem0';
+ * import { BrainRunner } from '@positronic/core';
+ *
+ * const provider = createMem0Provider({ apiKey: process.env.MEM0_API_KEY! });
+ * const adapter = createMem0Adapter({ provider });
+ *
+ * const runner = new BrainRunner({
+ *   adapters: [adapter],
+ *   client,
+ * });
+ *
+ * await runner.run(myBrain);
+ * ```
+ */
+export declare function createMem0Adapter(config: Mem0AdapterConfig): Adapter;
+//# sourceMappingURL=adapter.d.ts.map

package/dist/types/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAEP,cAAc,EAEf,MAAM,kBAAkB,CAAC;AAG1B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2DAA2D;IAC3D,QAAQ,EAAE,cAAc,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CA8GpE"}

package/dist/types/helpers.d.ts

@@ -0,0 +1,104 @@
+import type { Memory, ScopedMemory, MemorySearchOptions } from '@positronic/core';
+/**
+ * Options for formatting memories.
+ */
+export interface FormatMemoriesOptions {
+    /** Header text to include before the memories list */
+    header?: string;
+    /** Whether to include relevance scores (if available) */
+    includeScores?: boolean;
+    /** Text to return if no memories are found */
+    emptyText?: string;
+}
+/**
+ * Formats memories into a readable string format.
+ *
+ * @param memories - Array of memories to format
+ * @param options - Formatting options
+ * @returns Formatted string representation of the memories
+ *
+ * @example
+ * ```typescript
+ * const memories = await memory.search('user preferences');
+ * const formatted = formatMemories(memories);
+ * // Returns:
+ * // 1. User prefers dark mode
+ * // 2. User likes concise responses
+ *
+ * const formattedWithHeader = formatMemories(memories, {
+ *   header: 'Known user preferences:',
+ *   includeScores: true,
+ * });
+ * // Returns:
+ * // Known user preferences:
+ * // 1. User prefers dark mode (0.95)
+ * // 2. User likes concise responses (0.82)
+ * ```
+ */
+export declare function formatMemories(memories: Memory[], options?: FormatMemoriesOptions): string;
+/**
+ * Options for creating a memory-augmented system prompt.
+ */
+export interface CreateMemorySystemPromptOptions extends MemorySearchOptions {
+    /** Header text before the memories section */
+    memoriesHeader?: string;
+    /** Whether to include relevance scores */
+    includeScores?: boolean;
+}
+/**
+ * Creates a system prompt augmented with relevant memories.
+ *
+ * This is a convenience function that:
+ * 1. Fetches relevant memories using the provided query
+ * 2. Formats them nicely
+ * 3. Appends them to your base system prompt
+ *
+ * @param memory - The scoped memory instance
+ * @param basePrompt - The base system prompt
+ * @param query - The search query for finding relevant memories
+ * @param options - Search and formatting options
+ * @returns The augmented system prompt
+ *
+ * @example
+ * ```typescript
+ * const myBrain = brain('my-brain')
+ *   .withMemory(provider)
+ *   .brain('agent', async ({ memory }) => {
+ *     const system = await createMemorySystemPrompt(
+ *       memory,
+ *       'You are a helpful assistant.',
+ *       'user preferences',
+ *       { userId: 'user-123', memoriesHeader: '\n\nUser context:' }
+ *     );
+ *
+ *     return { system, prompt: 'Help me with my task' };
+ *   });
+ * ```
+ */
+export declare function createMemorySystemPrompt(memory: ScopedMemory, basePrompt: string, query: string, options?: CreateMemorySystemPromptOptions): Promise<string>;
+/**
+ * Creates a memory context block for including in prompts.
+ *
+ * Similar to createMemorySystemPrompt but returns just the memory
+ * context block, not the full system prompt. Useful when you want
+ * more control over prompt construction.
+ *
+ * @param memory - The scoped memory instance
+ * @param query - The search query for finding relevant memories
+ * @param options - Search and formatting options
+ * @returns Formatted memory context block or empty string
+ *
+ * @example
+ * ```typescript
+ * const context = await getMemoryContext(memory, 'user preferences', {
+ *   userId: 'user-123',
+ *   limit: 5,
+ * });
+ *
+ * const system = `You are helpful.
+ *
+ * ${context ? `User context:\n${context}` : ''}`;
+ * ```
+ */
+export declare function getMemoryContext(memory: ScopedMemory, query: string, options?: MemorySearchOptions): Promise<string>;
+//# sourceMappingURL=helpers.d.ts.map