@positronic/mem0 0.0.57

package/dist/src/adapter.js

@@ -0,0 +1,301 @@
+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 { BRAIN_EVENTS } from '@positronic/core';
+/**
+ * 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 function createMem0Adapter(config) {
+    var provider = config.provider, _config_includeToolCalls = config.includeToolCalls, includeToolCalls = _config_includeToolCalls === void 0 ? false : _config_includeToolCalls;
+    // Buffer messages per brainRunId
+    var buffers = new Map();
+    return {
+        dispatch: function dispatch(event) {
+            return _async_to_generator(function() {
+                var brainRunId, agentId, buffer, buffer1, buffer2, buffer3, buffer4;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            brainRunId = event.brainRunId;
+                            // Handle AGENT_START - initialize buffer for this run
+                            if (event.type === BRAIN_EVENTS.AGENT_START) {
+                                agentId = event.stepTitle; // Use step title as agentId
+                                // Initialize buffer if not exists
+                                if (!buffers.has(brainRunId)) {
+                                    buffers.set(brainRunId, {
+                                        agentId: agentId,
+                                        messages: []
+                                    });
+                                }
+                                // Add the initial user prompt as a message
+                                buffer = buffers.get(brainRunId);
+                                buffer.messages.push({
+                                    role: 'user',
+                                    content: event.prompt
+                                });
+                            }
+                            // Handle AGENT_USER_MESSAGE - add user message to buffer
+                            if (event.type === BRAIN_EVENTS.AGENT_USER_MESSAGE) {
+                                buffer1 = buffers.get(brainRunId);
+                                if (buffer1) {
+                                    buffer1.messages.push({
+                                        role: 'user',
+                                        content: event.content
+                                    });
+                                }
+                            }
+                            // Handle AGENT_ASSISTANT_MESSAGE - add assistant message to buffer
+                            if (event.type === BRAIN_EVENTS.AGENT_ASSISTANT_MESSAGE) {
+                                buffer2 = buffers.get(brainRunId);
+                                if (buffer2) {
+                                    buffer2.messages.push({
+                                        role: 'assistant',
+                                        content: event.content
+                                    });
+                                }
+                            }
+                            // Handle tool calls if configured
+                            if (includeToolCalls && event.type === BRAIN_EVENTS.AGENT_TOOL_CALL) {
+                                buffer3 = buffers.get(brainRunId);
+                                if (buffer3) {
+                                    buffer3.messages.push({
+                                        role: 'assistant',
+                                        content: "[Tool Call: ".concat(event.toolName, "] ").concat(JSON.stringify(event.input))
+                                    });
+                                }
+                            }
+                            if (includeToolCalls && event.type === BRAIN_EVENTS.AGENT_TOOL_RESULT) {
+                                buffer4 = buffers.get(brainRunId);
+                                if (buffer4) {
+                                    buffer4.messages.push({
+                                        role: 'assistant',
+                                        content: "[Tool Result: ".concat(event.toolName, "] ").concat(JSON.stringify(event.result))
+                                    });
+                                }
+                            }
+                            if (!(event.type === BRAIN_EVENTS.AGENT_COMPLETE)) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                flushBuffer(brainRunId)
+                            ];
+                        case 1:
+                            _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            if (!(event.type === BRAIN_EVENTS.COMPLETE)) return [
+                                3,
+                                4
+                            ];
+                            return [
+                                4,
+                                flushBuffer(brainRunId)
+                            ];
+                        case 3:
+                            _state.sent();
+                            _state.label = 4;
+                        case 4:
+                            // Handle ERROR - clean up buffer without flushing
+                            if (event.type === BRAIN_EVENTS.ERROR) {
+                                buffers.delete(brainRunId);
+                            }
+                            // Handle CANCELLED - clean up buffer without flushing
+                            if (event.type === BRAIN_EVENTS.CANCELLED) {
+                                buffers.delete(brainRunId);
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+    function flushBuffer(brainRunId) {
+        return _async_to_generator(function() {
+            var buffer;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        buffer = buffers.get(brainRunId);
+                        if (!buffer || buffer.messages.length === 0) {
+                            buffers.delete(brainRunId);
+                            return [
+                                2
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            ,
+                            3,
+                            4
+                        ]);
+                        return [
+                            4,
+                            provider.add(buffer.messages, {
+                                agentId: buffer.agentId
+                            })
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        buffers.delete(brainRunId);
+                        return [
+                            7
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }
+}

package/dist/src/helpers.js

@@ -0,0 +1,275 @@
+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
+        };
+    }
+}
+/**
+ * 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 function formatMemories(memories) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var header = options.header, _options_includeScores = options.includeScores, includeScores = _options_includeScores === void 0 ? false : _options_includeScores, _options_emptyText = options.emptyText, emptyText = _options_emptyText === void 0 ? '' : _options_emptyText;
+    if (!memories || memories.length === 0) {
+        return emptyText;
+    }
+    var lines = [];
+    if (header) {
+        lines.push(header);
+    }
+    memories.forEach(function(memory, index) {
+        var line = "".concat(index + 1, ". ").concat(memory.content);
+        if (includeScores && memory.score !== undefined) {
+            line += " (".concat(memory.score.toFixed(2), ")");
+        }
+        lines.push(line);
+    });
+    return lines.join('\n');
+}
+/**
+ * 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 function createMemorySystemPrompt(_0, _1, _2) {
+    return _async_to_generator(function(memory, basePrompt, query) {
+        var options, userId, limit, _options_memoriesHeader, memoriesHeader, _options_includeScores, includeScores, memories, formattedMemories;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 3 && _arguments[3] !== void 0 ? _arguments[3] : {};
+                    userId = options.userId, limit = options.limit, _options_memoriesHeader = options.memoriesHeader, memoriesHeader = _options_memoriesHeader === void 0 ? '\n\nRelevant context from previous interactions:' : _options_memoriesHeader, _options_includeScores = options.includeScores, includeScores = _options_includeScores === void 0 ? false : _options_includeScores;
+                    return [
+                        4,
+                        memory.search(query, {
+                            userId: userId,
+                            limit: limit
+                        })
+                    ];
+                case 1:
+                    memories = _state.sent();
+                    if (memories.length === 0) {
+                        return [
+                            2,
+                            basePrompt
+                        ];
+                    }
+                    formattedMemories = formatMemories(memories, {
+                        header: memoriesHeader,
+                        includeScores: includeScores
+                    });
+                    return [
+                        2,
+                        "".concat(basePrompt).concat(formattedMemories)
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+/**
+ * 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 function getMemoryContext(_0, _1) {
+    return _async_to_generator(function(memory, query) {
+        var options, memories;
+        var _arguments = arguments;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    options = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {};
+                    return [
+                        4,
+                        memory.search(query, options)
+                    ];
+                case 1:
+                    memories = _state.sent();
+                    return [
+                        2,
+                        formatMemories(memories, {
+                            emptyText: ''
+                        })
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}

package/dist/src/index.js

@@ -0,0 +1,8 @@
+// Provider
+export { createMem0Provider } from './provider.js';
+// Tools
+export { createMem0Tools, rememberFact, recallMemories } from './tools.js';
+// Adapter
+export { createMem0Adapter } from './adapter.js';
+// Helpers
+export { formatMemories, createMemorySystemPrompt, getMemoryContext } from './helpers.js';