indusagi 0.12.18 → 0.12.20

package/dist/memory/storage/inmemory.js

@@ -1,646 +0,0 @@
-/**
- * In-Memory Storage Implementation
- * Based on Mastra InMemoryMemory
- */
-import { MemoryStorage, normalizePerPage, calculatePagination, } from "./base.js";
-/**
- * Create a new in-memory database
- */
-export function createInMemoryDB() {
-    return {
-        threads: new Map(),
-        messages: new Map(),
-        resources: new Map(),
-        observationalMemory: new Map(),
-    };
-}
-/**
- * In-Memory Storage Implementation
- */
-export class InMemoryStorage extends MemoryStorage {
-    constructor(db) {
-        super();
-        this.name = "inmemory";
-        this.supportsObservationalMemory = true;
-        this.db = db ?? createInMemoryDB();
-    }
-    async init() {
-        // Nothing to initialize for in-memory storage
-    }
-    async dangerouslyClearAll() {
-        this.db.threads.clear();
-        this.db.messages.clear();
-        this.db.resources.clear();
-        this.db.observationalMemory.clear();
-    }
-    // ========================================================================
-    // Thread Operations
-    // ========================================================================
-    async getThreadById({ threadId }) {
-        const thread = this.db.threads.get(threadId);
-        return thread ? { ...thread, metadata: thread.metadata ? { ...thread.metadata } : thread.metadata } : null;
-    }
-    async saveThread({ thread }) {
-        this.db.threads.set(thread.id, thread);
-        return thread;
-    }
-    async updateThread({ id, title, metadata, }) {
-        const thread = this.db.threads.get(id);
-        if (!thread) {
-            throw new Error(`Thread with id ${id} not found`);
-        }
-        if (title !== undefined)
-            thread.title = title;
-        if (metadata !== undefined)
-            thread.metadata = { ...thread.metadata, ...metadata };
-        thread.updatedAt = new Date();
-        return thread;
-    }
-    async deleteThread({ threadId }) {
-        this.db.threads.delete(threadId);
-        // Delete all messages in the thread
-        for (const [key, msg] of this.db.messages) {
-            if (msg.thread_id === threadId) {
-                this.db.messages.delete(key);
-            }
-        }
-    }
-    async listThreads(args) {
-        const { page = 0, perPage: perPageInput, orderBy, filter } = args;
-        const { field, direction } = this.parseOrderBy(orderBy);
-        this.validatePaginationInput(page, perPageInput ?? 100);
-        const perPage = normalizePerPage(perPageInput, 100);
-        // Start with all threads
-        let threads = Array.from(this.db.threads.values());
-        // Apply resourceId filter if provided
-        if (filter?.resourceId) {
-            threads = threads.filter(t => t.resourceId === filter.resourceId);
-        }
-        // Validate and apply metadata filter
-        this.validateMetadataKeys(filter?.metadata);
-        if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
-            threads = threads.filter(thread => {
-                if (!thread.metadata)
-                    return false;
-                return Object.entries(filter.metadata).every(([key, value]) => deepEquals(thread.metadata[key], value));
-            });
-        }
-        // Sort threads
-        threads.sort((a, b) => {
-            const aValue = new Date(a[field]).getTime();
-            const bValue = new Date(b[field]).getTime();
-            return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        });
-        // Clone threads for output
-        const clonedThreads = threads.map(thread => ({
-            ...thread,
-            metadata: thread.metadata ? { ...thread.metadata } : thread.metadata,
-        }));
-        const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-        return {
-            threads: clonedThreads.slice(offset, offset + perPage),
-            total: clonedThreads.length,
-            page,
-            perPage: perPageForResponse,
-            hasMore: offset + perPage < clonedThreads.length,
-        };
-    }
-    // ========================================================================
-    // Message Operations
-    // ========================================================================
-    async listMessages({ threadId, resourceId: optionalResourceId, include, filter, perPage: perPageInput, page = 0, orderBy, }) {
-        const threadIds = Array.isArray(threadId) ? threadId : [threadId];
-        if (threadIds.length === 0 || threadIds.some(id => !id.trim())) {
-            throw new Error("threadId must be a non-empty string or array of non-empty strings");
-        }
-        const threadIdSet = new Set(threadIds);
-        const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-        const perPage = normalizePerPage(perPageInput, 40);
-        if (page < 0) {
-            throw new Error("page must be >= 0");
-        }
-        const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
-        // Get messages matching threadId(s)
-        let threadMessages = Array.from(this.db.messages.values()).filter(msg => {
-            if (threadIdSet && !threadIdSet.has(msg.thread_id))
-                return false;
-            if (optionalResourceId && msg.resourceId !== optionalResourceId)
-                return false;
-            return true;
-        });
-        // Apply date filtering
-        if (filter?.dateRange) {
-            const { start, end } = filter.dateRange;
-            if (start) {
-                threadMessages = threadMessages.filter(msg => new Date(msg.createdAt) >= start);
-            }
-            if (end) {
-                threadMessages = threadMessages.filter(msg => new Date(msg.createdAt) <= end);
-            }
-        }
-        // Sort messages
-        threadMessages.sort((a, b) => {
-            const aDate = field === "updatedAt" ? a.updatedAt : a.createdAt;
-            const bDate = field === "updatedAt" ? b.updatedAt : b.createdAt;
-            const aValue = new Date(aDate ?? a.createdAt).getTime();
-            const bValue = new Date(bDate ?? b.createdAt).getTime();
-            return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        });
-        const totalThreadMessages = threadMessages.length;
-        // Apply pagination
-        const paginatedMessages = threadMessages.slice(offset, offset + perPage);
-        // Convert to CoreMessage format
-        const messages = paginatedMessages.map(msg => this.parseStoredMessage(msg));
-        const messageIds = new Set(messages.map(m => m.id));
-        // Add included messages
-        if (include && include.length > 0) {
-            for (const includeItem of include) {
-                const targetMessage = this.db.messages.get(includeItem.id);
-                if (targetMessage && !messageIds.has(targetMessage.id)) {
-                    const convertedMessage = this.parseStoredMessage(targetMessage);
-                    messages.push(convertedMessage);
-                    messageIds.add(targetMessage.id);
-                }
-            }
-        }
-        // Final sort
-        messages.sort((a, b) => {
-            const aValue = new Date(a.createdAt).getTime();
-            const bValue = new Date(b.createdAt).getTime();
-            return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        });
-        return {
-            messages,
-            total: totalThreadMessages,
-            page,
-            perPage: perPageForResponse,
-            hasMore: offset + perPage < totalThreadMessages,
-        };
-    }
-    async listMessagesById({ messageIds }) {
-        const rawMessages = messageIds
-            .map(id => this.db.messages.get(id))
-            .filter((msg) => !!msg);
-        return {
-            messages: rawMessages.map(m => this.parseStoredMessage(m)),
-        };
-    }
-    async saveMessages(args) {
-        const { messages } = args;
-        // Update thread timestamps
-        const threadIds = new Set(messages.map(msg => msg.threadId).filter((id) => Boolean(id)));
-        for (const threadId of threadIds) {
-            const thread = this.db.threads.get(threadId);
-            if (thread) {
-                thread.updatedAt = new Date();
-            }
-        }
-        // Save messages
-        for (const message of messages) {
-            const storageMessage = {
-                id: message.id,
-                thread_id: message.threadId || "",
-                content: typeof message.content === "string"
-                    ? message.content
-                    : JSON.stringify(message.content),
-                role: message.role,
-                type: "text",
-                createdAt: message.createdAt,
-                resourceId: message.resourceId || null,
-            };
-            this.db.messages.set(message.id, storageMessage);
-        }
-        return { messages };
-    }
-    async updateMessages(args) {
-        const updatedMessages = [];
-        for (const update of args.messages) {
-            const storageMsg = this.db.messages.get(update.id);
-            if (!storageMsg)
-                continue;
-            if (update.role !== undefined)
-                storageMsg.role = update.role;
-            if (update.resourceId !== undefined)
-                storageMsg.resourceId = update.resourceId;
-            if (update.threadId !== undefined)
-                storageMsg.thread_id = update.threadId;
-            if (update.content !== undefined) {
-                storageMsg.content = typeof update.content === "string"
-                    ? update.content
-                    : JSON.stringify(update.content);
-            }
-            updatedMessages.push(this.parseStoredMessage(storageMsg));
-        }
-        return updatedMessages;
-    }
-    async deleteMessages(messageIds) {
-        if (!messageIds || messageIds.length === 0)
-            return;
-        const threadIds = new Set();
-        for (const messageId of messageIds) {
-            const message = this.db.messages.get(messageId);
-            if (message && message.thread_id) {
-                threadIds.add(message.thread_id);
-            }
-            this.db.messages.delete(messageId);
-        }
-        // Update thread timestamps
-        const now = new Date();
-        for (const threadId of threadIds) {
-            const thread = this.db.threads.get(threadId);
-            if (thread) {
-                thread.updatedAt = now;
-            }
-        }
-    }
-    // ========================================================================
-    // Resource Operations
-    // ========================================================================
-    async getResourceById({ resourceId }) {
-        const resource = this.db.resources.get(resourceId);
-        return resource
-            ? { ...resource, metadata: resource.metadata ? { ...resource.metadata } : resource.metadata }
-            : null;
-    }
-    async saveResource({ resource }) {
-        this.db.resources.set(resource.id, resource);
-        return resource;
-    }
-    async updateResource({ resourceId, workingMemory, metadata, }) {
-        let resource = this.db.resources.get(resourceId);
-        if (!resource) {
-            resource = {
-                id: resourceId,
-                workingMemory,
-                metadata: metadata || {},
-                createdAt: new Date(),
-                updatedAt: new Date(),
-            };
-        }
-        else {
-            resource = {
-                ...resource,
-                workingMemory: workingMemory !== undefined ? workingMemory : resource.workingMemory,
-                metadata: {
-                    ...resource.metadata,
-                    ...metadata,
-                },
-                updatedAt: new Date(),
-            };
-        }
-        this.db.resources.set(resourceId, resource);
-        return resource;
-    }
-    // ========================================================================
-    // Observational Memory Operations
-    // ========================================================================
-    getObservationalMemoryKey(threadId, resourceId) {
-        if (threadId) {
-            return `thread:${threadId}`;
-        }
-        return `resource:${resourceId}`;
-    }
-    async getObservationalMemory(threadId, resourceId) {
-        const key = this.getObservationalMemoryKey(threadId, resourceId);
-        const records = this.db.observationalMemory.get(key);
-        return records?.[0] ?? null;
-    }
-    async getObservationalMemoryHistory(threadId, resourceId, limit) {
-        const key = this.getObservationalMemoryKey(threadId, resourceId);
-        const records = this.db.observationalMemory.get(key) ?? [];
-        return limit != null ? records.slice(0, limit) : records;
-    }
-    async initializeObservationalMemory(input) {
-        const { threadId, resourceId, scope, config, observedTimezone } = input;
-        const key = this.getObservationalMemoryKey(threadId, resourceId);
-        const now = new Date();
-        const record = {
-            id: crypto.randomUUID(),
-            scope,
-            threadId,
-            resourceId,
-            createdAt: now,
-            updatedAt: now,
-            lastObservedAt: undefined,
-            originType: "initial",
-            generationCount: 0,
-            activeObservations: "",
-            bufferedObservationChunks: undefined,
-            bufferedReflection: undefined,
-            totalTokensObserved: 0,
-            observationTokenCount: 0,
-            pendingMessageTokens: 0,
-            isReflecting: false,
-            isObserving: false,
-            isBufferingObservation: false,
-            isBufferingReflection: false,
-            lastBufferedAtTokens: 0,
-            lastBufferedAtTime: null,
-            config,
-            observedTimezone,
-            metadata: {},
-        };
-        const existing = this.db.observationalMemory.get(key) ?? [];
-        this.db.observationalMemory.set(key, [record, ...existing]);
-        return record;
-    }
-    async insertObservationalMemoryRecord(record) {
-        const key = this.getObservationalMemoryKey(record.threadId, record.resourceId);
-        const existing = this.db.observationalMemory.get(key) ?? [];
-        let inserted = false;
-        for (let i = 0; i < existing.length; i++) {
-            if (record.generationCount >= existing[i].generationCount) {
-                existing.splice(i, 0, record);
-                inserted = true;
-                break;
-            }
-        }
-        if (!inserted)
-            existing.push(record);
-        this.db.observationalMemory.set(key, existing);
-    }
-    async updateActiveObservations(input) {
-        const { id, observations, tokenCount, lastObservedAt, observedMessageIds } = input;
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record) {
-            throw new Error(`Observational memory record not found: ${id}`);
-        }
-        record.activeObservations = observations;
-        record.observationTokenCount = tokenCount;
-        record.totalTokensObserved += tokenCount;
-        record.pendingMessageTokens = 0;
-        record.lastObservedAt = lastObservedAt;
-        record.updatedAt = new Date();
-        if (observedMessageIds) {
-            record.observedMessageIds = observedMessageIds;
-        }
-    }
-    async updateBufferedObservations(input) {
-        const { id, chunk, lastBufferedAtTime } = input;
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record) {
-            throw new Error(`Observational memory record not found: ${id}`);
-        }
-        const newChunk = {
-            id: `ombuf-${crypto.randomUUID()}`,
-            cycleId: chunk.cycleId,
-            observations: chunk.observations,
-            tokenCount: chunk.tokenCount,
-            messageIds: chunk.messageIds,
-            messageTokens: chunk.messageTokens,
-            lastObservedAt: chunk.lastObservedAt,
-            createdAt: new Date(),
-            suggestedContinuation: chunk.suggestedContinuation,
-            currentTask: chunk.currentTask,
-        };
-        const existingChunks = Array.isArray(record.bufferedObservationChunks)
-            ? record.bufferedObservationChunks
-            : [];
-        record.bufferedObservationChunks = [...existingChunks, newChunk];
-        if (lastBufferedAtTime) {
-            record.lastBufferedAtTime = lastBufferedAtTime;
-        }
-        record.updatedAt = new Date();
-    }
-    async swapBufferedToActive(input) {
-        const { id, activationRatio, lastObservedAt, messageTokensThreshold, currentPendingTokens, forceMaxActivation } = input;
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record) {
-            throw new Error(`Observational memory record not found: ${id}`);
-        }
-        const chunks = Array.isArray(record.bufferedObservationChunks)
-            ? record.bufferedObservationChunks
-            : [];
-        if (chunks.length === 0) {
-            return {
-                chunksActivated: 0,
-                messageTokensActivated: 0,
-                observationTokensActivated: 0,
-                messagesActivated: 0,
-                activatedCycleIds: [],
-                activatedMessageIds: [],
-            };
-        }
-        const retentionFloor = messageTokensThreshold * (1 - activationRatio);
-        const targetMessageTokens = Math.max(0, currentPendingTokens - retentionFloor);
-        let cumulativeMessageTokens = 0;
-        let chunksToActivate = 1;
-        for (let i = 0; i < chunks.length; i++) {
-            cumulativeMessageTokens += chunks[i].messageTokens ?? 0;
-            if (cumulativeMessageTokens >= targetMessageTokens) {
-                chunksToActivate = i + 1;
-                break;
-            }
-        }
-        const activatedChunks = chunks.slice(0, chunksToActivate);
-        const remainingChunks = chunks.slice(chunksToActivate);
-        const activatedContent = activatedChunks.map(c => c.observations).join("\n\n");
-        const activatedTokens = activatedChunks.reduce((sum, c) => sum + c.tokenCount, 0);
-        const activatedMessageTokens = activatedChunks.reduce((sum, c) => sum + (c.messageTokens ?? 0), 0);
-        const activatedMessageCount = activatedChunks.reduce((sum, c) => sum + c.messageIds.length, 0);
-        const activatedCycleIds = activatedChunks.map(c => c.cycleId).filter((id) => !!id);
-        const activatedMessageIds = activatedChunks.flatMap(c => c.messageIds);
-        const latestChunk = activatedChunks[activatedChunks.length - 1];
-        const derivedLastObservedAt = lastObservedAt ??
-            (latestChunk?.lastObservedAt ? new Date(latestChunk.lastObservedAt) : new Date());
-        if (record.activeObservations) {
-            record.activeObservations = `${record.activeObservations}\n\n${activatedContent}`;
-        }
-        else {
-            record.activeObservations = activatedContent;
-        }
-        record.observationTokenCount = (record.observationTokenCount ?? 0) + activatedTokens;
-        record.pendingMessageTokens = Math.max(0, (record.pendingMessageTokens ?? 0) - activatedMessageTokens);
-        record.bufferedObservationChunks = remainingChunks.length > 0 ? remainingChunks : undefined;
-        record.lastObservedAt = derivedLastObservedAt;
-        record.updatedAt = new Date();
-        return {
-            chunksActivated: activatedChunks.length,
-            messageTokensActivated: activatedMessageTokens,
-            observationTokensActivated: activatedTokens,
-            messagesActivated: activatedMessageCount,
-            activatedCycleIds,
-            activatedMessageIds,
-            observations: activatedContent,
-            suggestedContinuation: latestChunk?.suggestedContinuation ?? undefined,
-            currentTask: latestChunk?.currentTask ?? undefined,
-        };
-    }
-    async createReflectionGeneration(input) {
-        const { currentRecord, reflection, tokenCount } = input;
-        const key = this.getObservationalMemoryKey(currentRecord.threadId, currentRecord.resourceId);
-        const now = new Date();
-        const newRecord = {
-            id: crypto.randomUUID(),
-            scope: currentRecord.scope,
-            threadId: currentRecord.threadId,
-            resourceId: currentRecord.resourceId,
-            createdAt: now,
-            updatedAt: now,
-            lastObservedAt: currentRecord.lastObservedAt ?? now,
-            originType: "reflection",
-            generationCount: currentRecord.generationCount + 1,
-            activeObservations: reflection,
-            config: currentRecord.config,
-            totalTokensObserved: currentRecord.totalTokensObserved,
-            observationTokenCount: tokenCount,
-            pendingMessageTokens: 0,
-            isReflecting: false,
-            isObserving: false,
-            isBufferingObservation: false,
-            isBufferingReflection: false,
-            lastBufferedAtTokens: 0,
-            lastBufferedAtTime: null,
-            observedTimezone: currentRecord.observedTimezone,
-            metadata: {},
-        };
-        const existing = this.db.observationalMemory.get(key) ?? [];
-        this.db.observationalMemory.set(key, [newRecord, ...existing]);
-        return newRecord;
-    }
-    async updateBufferedReflection(input) {
-        const { id, reflection, tokenCount, inputTokenCount, reflectedObservationLineCount } = input;
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record) {
-            throw new Error(`Observational memory record not found: ${id}`);
-        }
-        const existing = record.bufferedReflection || "";
-        record.bufferedReflection = existing ? `${existing}\n\n${reflection}` : reflection;
-        record.bufferedReflectionTokens = (record.bufferedReflectionTokens || 0) + tokenCount;
-        record.bufferedReflectionInputTokens = (record.bufferedReflectionInputTokens || 0) + inputTokenCount;
-        record.reflectedObservationLineCount = reflectedObservationLineCount;
-        record.updatedAt = new Date();
-    }
-    async swapBufferedReflectionToActive(input) {
-        const { currentRecord, tokenCount } = input;
-        const record = this.findObservationalMemoryRecordById(currentRecord.id);
-        if (!record) {
-            throw new Error(`Observational memory record not found: ${currentRecord.id}`);
-        }
-        if (!record.bufferedReflection) {
-            throw new Error("No buffered reflection to swap");
-        }
-        const bufferedReflection = record.bufferedReflection;
-        const reflectedLineCount = record.reflectedObservationLineCount ?? 0;
-        const currentObservations = record.activeObservations ?? "";
-        const allLines = currentObservations.split("\n");
-        const unreflectedLines = allLines.slice(reflectedLineCount);
-        const unreflectedContent = unreflectedLines.join("\n").trim();
-        const newObservations = unreflectedContent
-            ? `${bufferedReflection}\n\n${unreflectedContent}`
-            : bufferedReflection;
-        const newRecord = await this.createReflectionGeneration({
-            currentRecord: record,
-            reflection: newObservations,
-            tokenCount,
-        });
-        record.bufferedReflection = undefined;
-        record.bufferedReflectionTokens = undefined;
-        record.bufferedReflectionInputTokens = undefined;
-        record.reflectedObservationLineCount = undefined;
-        return newRecord;
-    }
-    async setReflectingFlag(id, isReflecting) {
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record)
-            throw new Error(`Observational memory record not found: ${id}`);
-        record.isReflecting = isReflecting;
-        record.updatedAt = new Date();
-    }
-    async setObservingFlag(id, isObserving) {
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record)
-            throw new Error(`Observational memory record not found: ${id}`);
-        record.isObserving = isObserving;
-        record.updatedAt = new Date();
-    }
-    async setBufferingObservationFlag(id, isBuffering, lastBufferedAtTokens) {
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record)
-            throw new Error(`Observational memory record not found: ${id}`);
-        record.isBufferingObservation = isBuffering;
-        if (lastBufferedAtTokens !== undefined) {
-            record.lastBufferedAtTokens = lastBufferedAtTokens;
-        }
-        record.updatedAt = new Date();
-    }
-    async setBufferingReflectionFlag(id, isBuffering) {
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record)
-            throw new Error(`Observational memory record not found: ${id}`);
-        record.isBufferingReflection = isBuffering;
-        record.updatedAt = new Date();
-    }
-    async clearObservationalMemory(threadId, resourceId) {
-        const key = this.getObservationalMemoryKey(threadId, resourceId);
-        this.db.observationalMemory.delete(key);
-    }
-    async setPendingMessageTokens(id, tokenCount) {
-        const record = this.findObservationalMemoryRecordById(id);
-        if (!record)
-            throw new Error(`Observational memory record not found: ${id}`);
-        record.pendingMessageTokens = tokenCount;
-        record.updatedAt = new Date();
-    }
-    // ========================================================================
-    // Private Helpers
-    // ========================================================================
-    parseStoredMessage(message) {
-        let parsedContent;
-        try {
-            const parsed = JSON.parse(message.content);
-            if (typeof parsed === "string") {
-                parsedContent = {
-                    format: 2,
-                    content: parsed,
-                    parts: [{ type: "text", text: parsed }],
-                };
-            }
-            else {
-                parsedContent = parsed;
-            }
-        }
-        catch {
-            parsedContent = {
-                format: 2,
-                content: message.content,
-                parts: [{ type: "text", text: message.content }],
-            };
-        }
-        return {
-            id: message.id,
-            threadId: message.thread_id,
-            content: parsedContent,
-            role: message.role,
-            createdAt: message.createdAt,
-            resourceId: message.resourceId ?? undefined,
-        };
-    }
-    findObservationalMemoryRecordById(id) {
-        for (const records of this.db.observationalMemory.values()) {
-            const record = records.find(r => r.id === id);
-            if (record)
-                return record;
-        }
-        return null;
-    }
-}
-/**
- * Deep equality check
- */
-function deepEquals(a, b) {
-    if (a === b)
-        return true;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a !== "object" || a === null || b === null)
-        return false;
-    const aObj = a;
-    const bObj = b;
-    const aKeys = Object.keys(aObj);
-    const bKeys = Object.keys(bObj);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    return aKeys.every(key => deepEquals(aObj[key], bObj[key]));
-}
-//# sourceMappingURL=inmemory.js.map