@looopy-ai/core 1.0.1

package/dist/stores/messages/mem0-message-store.d.ts

@@ -0,0 +1,34 @@
+import type { Message } from '../../types/message';
+import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
+type MemoryClient = any;
+export type Mem0MemoryLevel = 'conversation' | 'session' | 'user' | 'org';
+export interface Mem0Config {
+    apiKey?: string;
+    memoryLevel?: Mem0MemoryLevel;
+    enableGraph?: boolean;
+    inferMemories?: boolean;
+    client?: MemoryClient;
+    orgId?: string;
+}
+export declare class Mem0MessageStore implements MessageStore {
+    private client;
+    private config;
+    private messageCache;
+    constructor(config: Mem0Config);
+    append(contextId: string, messages: Message[]): Promise<void>;
+    getRecent(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+    private searchMemories;
+    private formatMemoriesAsContext;
+    getAll(contextId: string): Promise<Message[]>;
+    getCount(contextId: string): Promise<number>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
+    clear(contextId: string): Promise<void>;
+    private extractUserId;
+    updateMemory(memoryId: string, data: string): Promise<void>;
+    getAllMemories(contextId: string): Promise<unknown[]>;
+}
+export {};

package/dist/stores/messages/mem0-message-store.js

@@ -0,0 +1,218 @@
+import { estimateTokens, trimToTokenBudget } from './interfaces';
+export class Mem0MessageStore {
+    client;
+    config;
+    messageCache = new Map();
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey || '',
+            memoryLevel: config.memoryLevel || 'user',
+            enableGraph: config.enableGraph ?? true,
+            inferMemories: config.inferMemories ?? true,
+            client: config.client,
+            orgId: config.orgId || 'default-org',
+        };
+        if (config.client) {
+            this.client = config.client;
+        }
+        else {
+            try {
+                const { MemoryClient } = require('mem0ai');
+                this.client = new MemoryClient({ apiKey: this.config.apiKey });
+            }
+            catch {
+                throw new Error('Mem0 SDK not found. Install mem0ai package');
+            }
+        }
+    }
+    async append(contextId, messages) {
+        const cached = this.messageCache.get(contextId) || [];
+        const nextIndex = cached.length;
+        const storedMessages = messages.map((msg, i) => ({
+            ...msg,
+            id: `msg_${contextId}_${nextIndex + i}`,
+            contextId,
+            index: nextIndex + i,
+            timestamp: new Date().toISOString(),
+            tokens: estimateTokens(msg.content),
+        }));
+        this.messageCache.set(contextId, [...cached, ...storedMessages]);
+        try {
+            const mem0Messages = messages.map((msg) => ({
+                role: msg.role,
+                content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+            }));
+            const params = {
+                messages: mem0Messages,
+                infer: this.config.inferMemories,
+                metadata: {
+                    contextId,
+                    timestamp: new Date().toISOString(),
+                },
+            };
+            switch (this.config.memoryLevel) {
+                case 'conversation':
+                    params.session_id = `conv_${contextId}`;
+                    break;
+                case 'session':
+                    params.session_id = contextId;
+                    break;
+                case 'user':
+                    params.user_id = this.extractUserId(contextId);
+                    break;
+                case 'org':
+                    params.org_id = this.config.orgId;
+                    break;
+            }
+            if (this.config.enableGraph) {
+                params.enable_graph = true;
+            }
+            await this.client.add(params);
+        }
+        catch (error) {
+            console.error('Failed to add memories to Mem0:', error);
+        }
+    }
+    async getRecent(contextId, options) {
+        const cached = this.messageCache.get(contextId) || [];
+        const { maxMessages = 50, maxTokens } = options || {};
+        let messages = cached.slice(-maxMessages);
+        if (maxTokens) {
+            messages = trimToTokenBudget(messages, maxTokens);
+        }
+        try {
+            const memories = await this.searchMemories(contextId);
+            if (memories.length > 0) {
+                const memoryContext = {
+                    role: 'system',
+                    content: this.formatMemoriesAsContext(memories),
+                };
+                messages = [memoryContext, ...messages];
+            }
+        }
+        catch (error) {
+            console.error('Failed to search Mem0 memories:', error);
+        }
+        return messages;
+    }
+    async searchMemories(contextId, query) {
+        try {
+            const params = {
+                query: query || 'relevant context',
+                limit: 10,
+                filters: {
+                    contextId,
+                },
+            };
+            switch (this.config.memoryLevel) {
+                case 'conversation':
+                    params.session_id = `conv_${contextId}`;
+                    break;
+                case 'session':
+                    params.session_id = contextId;
+                    break;
+                case 'user':
+                    params.user_id = this.extractUserId(contextId);
+                    break;
+                case 'org':
+                    params.org_id = this.config.orgId;
+                    break;
+            }
+            const response = await this.client.search(params);
+            return response.results || [];
+        }
+        catch (error) {
+            console.error('Failed to search Mem0 memories:', error);
+            return [];
+        }
+    }
+    formatMemoriesAsContext(memories) {
+        if (memories.length === 0)
+            return '';
+        const memoryLines = memories.map((m) => {
+            const record = m;
+            return `- ${String(record.memory || m)}`;
+        });
+        return `Relevant memories from previous conversations:\n${memoryLines.join('\n')}`;
+    }
+    async getAll(contextId) {
+        return this.messageCache.get(contextId) || [];
+    }
+    async getCount(contextId) {
+        const messages = this.messageCache.get(contextId) || [];
+        return messages.length;
+    }
+    async getRange(contextId, startIndex, endIndex) {
+        const all = this.messageCache.get(contextId) || [];
+        return all.slice(startIndex, endIndex);
+    }
+    async compact(contextId, options) {
+        const cached = this.messageCache.get(contextId) || [];
+        const keepRecent = options?.keepRecent || 50;
+        if (cached.length > keepRecent) {
+            const oldMessages = cached.slice(0, -keepRecent);
+            const recentMessages = cached.slice(-keepRecent);
+            this.messageCache.set(contextId, recentMessages);
+            return {
+                summaryMessages: [],
+                compactedRange: { start: 0, end: oldMessages.length },
+                tokensSaved: oldMessages.reduce((sum, m) => sum + (m.tokens || 0), 0),
+            };
+        }
+        return {
+            summaryMessages: [],
+            compactedRange: { start: 0, end: 0 },
+            tokensSaved: 0,
+        };
+    }
+    async clear(contextId) {
+        this.messageCache.delete(contextId);
+        try {
+            const memories = await this.searchMemories(contextId);
+            for (const memory of memories) {
+                const record = memory;
+                if (record.id) {
+                    await this.client.delete(record.id);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to clear Mem0 memories:', error);
+        }
+    }
+    extractUserId(contextId) {
+        const parts = contextId.split('_');
+        return parts[0] || contextId;
+    }
+    async updateMemory(memoryId, data) {
+        try {
+            await this.client.update(memoryId, { data });
+        }
+        catch (error) {
+            console.error('Failed to update Mem0 memory:', error);
+            throw error;
+        }
+    }
+    async getAllMemories(contextId) {
+        try {
+            const params = {};
+            switch (this.config.memoryLevel) {
+                case 'user':
+                    params.user_id = this.extractUserId(contextId);
+                    break;
+                case 'session':
+                    params.session_id = contextId;
+                    break;
+                case 'org':
+                    params.org_id = this.config.orgId;
+                    break;
+            }
+            const response = await this.client.get_all(params);
+            return response.results || [];
+        }
+        catch (error) {
+            console.error('Failed to get all Mem0 memories:', error);
+            return [];
+        }
+    }
+}

package/dist/stores/messages/memory-message-store.d.ts

@@ -0,0 +1,27 @@
+import type { LLMProvider } from '../../types/llm';
+import type { Message } from '../../types/message';
+import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
+export interface InMemoryMessageStoreConfig {
+    llmProvider?: LLMProvider;
+    defaultSummaryPrompt?: string;
+}
+export declare class InMemoryMessageStore implements MessageStore {
+    private messages;
+    private config;
+    constructor(config?: InMemoryMessageStoreConfig);
+    append(contextId: string, messages: Message[]): Promise<void>;
+    getRecent(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+    getAll(contextId: string): Promise<Message[]>;
+    getCount(contextId: string): Promise<number>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
+    clear(contextId: string): Promise<void>;
+    private compactSlidingWindow;
+    private compactWithSummarization;
+    private compactHierarchical;
+    private createSummary;
+    private createLLMSummary;
+}

package/dist/stores/messages/memory-message-store.js

@@ -0,0 +1,183 @@
+import { filter, firstValueFrom } from 'rxjs';
+import { estimateTokens, trimToTokenBudget } from './interfaces';
+export class InMemoryMessageStore {
+    messages = new Map();
+    config;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    async append(contextId, messages) {
+        const stored = this.messages.get(contextId) || [];
+        const nextIndex = stored.length;
+        const newMessages = messages.map((msg, i) => ({
+            ...msg,
+            id: `msg_${contextId}_${nextIndex + i}`,
+            contextId,
+            index: nextIndex + i,
+            timestamp: new Date().toISOString(),
+            tokens: estimateTokens(msg.content),
+        }));
+        this.messages.set(contextId, [...stored, ...newMessages]);
+    }
+    async getRecent(contextId, options) {
+        const all = this.messages.get(contextId) || [];
+        const { maxMessages = 50, maxTokens } = options || {};
+        let messages = all.slice(-maxMessages);
+        if (maxTokens) {
+            messages = trimToTokenBudget(messages, maxTokens);
+        }
+        return messages;
+    }
+    async getAll(contextId) {
+        return this.messages.get(contextId) || [];
+    }
+    async getCount(contextId) {
+        const messages = this.messages.get(contextId) || [];
+        return messages.length;
+    }
+    async getRange(contextId, startIndex, endIndex) {
+        const all = this.messages.get(contextId) || [];
+        return all.slice(startIndex, endIndex);
+    }
+    async compact(contextId, options) {
+        const all = this.messages.get(contextId) || [];
+        const keepRecent = options?.keepRecent || 50;
+        if (all.length <= keepRecent) {
+            return {
+                summaryMessages: [],
+                compactedRange: { start: 0, end: 0 },
+                tokensSaved: 0,
+            };
+        }
+        const strategy = options?.strategy || 'sliding-window';
+        switch (strategy) {
+            case 'sliding-window':
+                return this.compactSlidingWindow(contextId, keepRecent);
+            case 'summarization':
+                return this.compactWithSummarization(contextId, keepRecent, options?.summaryPrompt);
+            case 'hierarchical':
+                return this.compactHierarchical(contextId, keepRecent);
+            default:
+                throw new Error(`Unknown compaction strategy: ${strategy}`);
+        }
+    }
+    async clear(contextId) {
+        this.messages.delete(contextId);
+    }
+    async compactSlidingWindow(contextId, keepRecent) {
+        const all = this.messages.get(contextId) || [];
+        const oldMessages = all.slice(0, -keepRecent);
+        const recentMessages = all.slice(-keepRecent);
+        const tokensSaved = oldMessages.reduce((sum, m) => sum + (m.tokens || 0), 0);
+        this.messages.set(contextId, recentMessages);
+        return {
+            summaryMessages: [],
+            compactedRange: { start: 0, end: oldMessages.length },
+            tokensSaved,
+        };
+    }
+    async compactWithSummarization(contextId, keepRecent, summaryPrompt) {
+        const all = this.messages.get(contextId) || [];
+        const oldMessages = all.slice(0, -keepRecent);
+        const recentMessages = all.slice(-keepRecent);
+        const summaryContent = await this.createSummary(oldMessages, summaryPrompt);
+        const summary = {
+            role: 'system',
+            content: summaryContent,
+        };
+        const summaryStored = {
+            ...summary,
+            id: `summary_${contextId}_${Date.now()}`,
+            contextId,
+            index: 0,
+            timestamp: new Date().toISOString(),
+            tokens: estimateTokens(summary.content),
+            compacted: true,
+            summarizedRange: { start: 0, end: oldMessages.length },
+        };
+        const tokensSaved = oldMessages.reduce((sum, m) => sum + (m.tokens || 0), 0) - (summaryStored.tokens || 0);
+        this.messages.set(contextId, [summaryStored, ...recentMessages]);
+        return {
+            summaryMessages: [summary],
+            compactedRange: { start: 0, end: oldMessages.length },
+            tokensSaved,
+        };
+    }
+    async compactHierarchical(contextId, keepRecent) {
+        const all = this.messages.get(contextId) || [];
+        const oldMessages = all.slice(0, -keepRecent);
+        const recentMessages = all.slice(-keepRecent);
+        const summaries = [];
+        let tokensSaved = 0;
+        for (let i = 0; i < oldMessages.length; i += 10) {
+            const chunk = oldMessages.slice(i, Math.min(i + 10, oldMessages.length));
+            const summaryContent = await this.createSummary(chunk);
+            const summary = {
+                role: 'system',
+                content: summaryContent,
+            };
+            const summaryStored = {
+                ...summary,
+                id: `summary_${contextId}_${i}`,
+                contextId,
+                index: i,
+                timestamp: new Date().toISOString(),
+                tokens: estimateTokens(summary.content),
+                compacted: true,
+                summarizedRange: { start: i, end: i + chunk.length },
+            };
+            summaries.push(summaryStored);
+            tokensSaved +=
+                chunk.reduce((sum, m) => sum + (m.tokens || 0), 0) - (summaryStored.tokens || 0);
+        }
+        this.messages.set(contextId, [...summaries, ...recentMessages]);
+        return {
+            summaryMessages: summaries,
+            compactedRange: { start: 0, end: oldMessages.length },
+            tokensSaved,
+        };
+    }
+    async createSummary(messages, customPrompt) {
+        if (this.config.llmProvider) {
+            try {
+                return await this.createLLMSummary(messages, customPrompt);
+            }
+            catch (error) {
+                console.warn('LLM summarization failed, falling back to rule-based:', error);
+            }
+        }
+        if (customPrompt) {
+            return `${customPrompt}\n\nMessages:\n${messages.map((m) => `${m.role}: ${m.content}`).join('\n')}`;
+        }
+        const userMessages = messages.filter((m) => m.role === 'user');
+        const assistantMessages = messages.filter((m) => m.role === 'assistant');
+        return `Summary of ${messages.length} messages: ${userMessages.length} user messages, ${assistantMessages.length} assistant responses.`;
+    }
+    async createLLMSummary(messages, customPrompt) {
+        if (!this.config.llmProvider) {
+            throw new Error('LLM Provider not configured for summarization');
+        }
+        const summaryPrompt = customPrompt ||
+            this.config.defaultSummaryPrompt ||
+            'Please provide a concise summary of the following conversation, capturing the key points and context:';
+        const conversationText = messages
+            .filter((m) => ['user', 'assistant'].includes(m.role))
+            .map((m) => `${m.role.toUpperCase()}: ${m.content}`)
+            .join('\n');
+        const summaryMessages = [
+            {
+                role: 'user',
+                content: `${summaryPrompt}\n\n${conversationText}`,
+            },
+        ];
+        const response$ = this.config.llmProvider.call({
+            messages: summaryMessages,
+            stream: false,
+        });
+        const completeEvent = await firstValueFrom(response$.pipe(filter((event) => event.kind === 'content-complete')));
+        if (completeEvent.content) {
+            return completeEvent.content;
+        }
+        throw new Error('Failed to get summary from LLM');
+    }
+}

package/dist/tools/artifact-tools.d.ts

@@ -0,0 +1,4 @@
+import type { ArtifactStore } from '../types/artifact';
+import type { TaskStateStore } from '../types/state';
+import type { ToolProvider } from '../types/tools';
+export declare function createArtifactTools(artifactStore: ArtifactStore, taskStateStore: TaskStateStore): ToolProvider;