@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-memory/evaluators/long-term-extraction.js

@@ -0,0 +1,199 @@
+import { requireEvaluatorSpec } from "../../../generated/spec-helpers.js";
+import { logger } from "../../../logger.js";
+import { ModelType, } from "../../../types/index.js";
+import { getErrorMessage, isTransientModelError, } from "../../../utils/model-errors.js";
+import { composePromptFromState, parseKeyValueXml } from "../../../utils.js";
+import { toEvaluationExamples } from "../../evaluator-doc-examples.js";
+import { longTermExtractionTemplate } from "../prompts.js";
+import { logAdvancedMemoryTrajectory } from "../trajectory.js";
+import { LongTermMemoryCategory } from "../types.js";
+const spec = requireEvaluatorSpec("LONG_TERM_MEMORY_EXTRACTION");
+const validMemoryCategories = new Set(Object.values(LongTermMemoryCategory));
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseMemoryExtractionResponse(text) {
+    const parsed = parseKeyValueXml(text);
+    if (parsed) {
+        const rawMemories = parsed.memories;
+        const candidateEntries = Array.isArray(rawMemories)
+            ? rawMemories
+            : isRecord(rawMemories) && "memory" in rawMemories
+                ? Array.isArray(rawMemories.memory)
+                    ? rawMemories.memory
+                    : [rawMemories.memory]
+                : [];
+        const memories = candidateEntries
+            .filter(isRecord)
+            .map((entry) => {
+            const category = typeof entry.category === "string"
+                ? entry.category.trim()
+                : null;
+            const content = typeof entry.content === "string" ? entry.content.trim() : "";
+            const confidenceRaw = entry.confidence;
+            const confidence = typeof confidenceRaw === "number"
+                ? confidenceRaw
+                : Number.parseFloat(String(confidenceRaw ?? "").trim());
+            if (!category || !validMemoryCategories.has(category)) {
+                return null;
+            }
+            if (!content || Number.isNaN(confidence)) {
+                return null;
+            }
+            return { category, content, confidence };
+        })
+            .filter((entry) => entry !== null);
+        if (memories.length > 0) {
+            return memories;
+        }
+    }
+    const memoryMatches = text.matchAll(/<memory>[\s\S]*?<category>(.*?)<\/category>[\s\S]*?<content>(.*?)<\/content>[\s\S]*?<confidence>(.*?)<\/confidence>[\s\S]*?<\/memory>/g);
+    const extractions = [];
+    for (const match of memoryMatches) {
+        const category = match[1].trim();
+        const content = match[2].trim();
+        const confidence = Number.parseFloat(match[3].trim());
+        if (!validMemoryCategories.has(category)) {
+            logger.warn({ src: "evaluator:memory" }, `Invalid memory category: ${category}`);
+            continue;
+        }
+        if (content && !Number.isNaN(confidence)) {
+            extractions.push({ category, content, confidence });
+        }
+    }
+    return extractions;
+}
+export const longTermExtractionEvaluator = {
+    name: spec.name,
+    description: spec.description,
+    similes: spec.similes ? [...spec.similes] : [],
+    alwaysRun: spec.alwaysRun ?? true,
+    examples: toEvaluationExamples(spec.examples),
+    validate: async (runtime, message) => {
+        if (message.entityId === runtime.agentId)
+            return false;
+        if (!message.content?.text)
+            return false;
+        const memoryService = runtime.getService("memory");
+        if (!memoryService)
+            return false;
+        const config = memoryService.getConfig();
+        if (!config.longTermExtractionEnabled) {
+            logger.debug({ src: "evaluator:memory" }, "Long-term memory extraction is disabled");
+            return false;
+        }
+        const currentMessageCount = await runtime.countMemories({
+            roomIds: [message.roomId],
+            unique: false,
+            tableName: "messages",
+        });
+        return memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
+    },
+    handler: async (runtime, message) => {
+        const memoryService = runtime.getService("memory");
+        if (!memoryService) {
+            logger.error({ src: "evaluator:memory" }, "MemoryService not found");
+            return undefined;
+        }
+        const config = memoryService.getConfig();
+        const { entityId, roomId } = message;
+        try {
+            logger.info({ src: "evaluator:memory" }, `Extracting long-term memories for entity ${entityId}`);
+            const recentMessages = await runtime.getMemories({
+                tableName: "messages",
+                roomId,
+                limit: 20,
+                unique: false,
+            });
+            const agentName = runtime.character.name ?? "Agent";
+            const formattedMessages = recentMessages
+                .sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0))
+                .map((msg) => {
+                const sender = msg.entityId === runtime.agentId ? agentName : "User";
+                return `${sender}: ${msg.content.text || "[non-text message]"}`;
+            })
+                .join("\n");
+            const existingMemories = await memoryService.getLongTermMemories(entityId, undefined, 30);
+            let formattedExisting = "None yet";
+            if (existingMemories.length > 0) {
+                const lines = [];
+                for (const memory of existingMemories) {
+                    lines.push(`[${memory.category}] ${memory.content} (confidence: ${memory.confidence})`);
+                }
+                formattedExisting = lines.join("\n");
+            }
+            const state = await runtime.composeState(message);
+            const prompt = composePromptFromState({
+                state: {
+                    ...state,
+                    recentMessages: formattedMessages,
+                    existingMemories: formattedExisting,
+                },
+                template: longTermExtractionTemplate,
+            });
+            const modelType = (config.summaryModelType ??
+                ModelType.TEXT_NANO);
+            const response = await runtime.useModel(modelType, { prompt });
+            const extractions = parseMemoryExtractionResponse(response);
+            logger.info({ src: "evaluator:memory" }, `Extracted ${extractions.length} long-term memories`);
+            const minConfidence = Math.max(config.longTermConfidenceThreshold, 0.85);
+            const extractedAt = new Date().toISOString();
+            let storedCount = 0;
+            await Promise.all(extractions.map(async (extraction) => {
+                if (extraction.confidence >= minConfidence) {
+                    await memoryService.storeLongTermMemory({
+                        agentId: runtime.agentId,
+                        entityId,
+                        category: extraction.category,
+                        content: extraction.content,
+                        confidence: extraction.confidence,
+                        source: "conversation",
+                        metadata: {
+                            roomId,
+                            extractedAt,
+                        },
+                    });
+                    storedCount += 1;
+                    logger.info({ src: "evaluator:memory" }, `Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
+                }
+                else {
+                    logger.debug({ src: "evaluator:memory" }, `Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
+                }
+            }));
+            logAdvancedMemoryTrajectory({
+                runtime,
+                message,
+                providerName: "LONG_TERM_MEMORY_EXTRACTION",
+                purpose: "evaluate",
+                data: {
+                    recentMessageCount: recentMessages.length,
+                    existingMemoryCount: existingMemories.length,
+                    extractedMemoryCount: extractions.length,
+                    storedMemoryCount: storedCount,
+                },
+                query: {
+                    modelType: String(modelType),
+                    entityId,
+                    roomId,
+                },
+            });
+            const currentMessageCount = await runtime.countMemories({
+                roomIds: [roomId],
+                unique: false,
+                tableName: "messages",
+            });
+            await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
+            logger.debug({ src: "evaluator:memory" }, `Updated checkpoint to ${currentMessageCount} for entity ${entityId}`);
+        }
+        catch (error) {
+            const err = getErrorMessage(error);
+            if (isTransientModelError(error)) {
+                logger.warn({ src: "evaluator:memory", err }, "Skipped long-term memory extraction due to transient model availability issue");
+            }
+            else {
+                logger.error({ src: "evaluator:memory", err }, "Error during long-term memory extraction");
+            }
+        }
+        return undefined;
+    },
+};

package/packages/typescript/src/features/advanced-memory/evaluators/summarization.d.ts

@@ -0,0 +1,3 @@
+import { type Evaluator } from "../../../types/index.ts";
+export declare const summarizationEvaluator: Evaluator;
+//# sourceMappingURL=summarization.d.ts.map

package/packages/typescript/src/features/advanced-memory/evaluators/summarization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarization.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-memory/evaluators/summarization.ts"],"names":[],"mappings":"AAEA,OAAO,EAEN,KAAK,SAAS,EAMd,MAAM,yBAAyB,CAAC;AAwGjC,eAAO,MAAM,sBAAsB,EAAE,SAqOpC,CAAC"}

package/packages/typescript/src/features/advanced-memory/evaluators/summarization.js

@@ -0,0 +1,240 @@
+import { requireEvaluatorSpec } from "../../../generated/spec-helpers.js";
+import { logger } from "../../../logger.js";
+import { ModelType, } from "../../../types/index.js";
+import { composePromptFromState, parseKeyValueXml } from "../../../utils.js";
+import { initialSummarizationTemplate, updateSummarizationTemplate, } from "../prompts.js";
+import { logAdvancedMemoryTrajectory } from "../trajectory.js";
+// Get text content from centralized specs
+const spec = requireEvaluatorSpec("MEMORY_SUMMARIZATION");
+function isDialogueMessage(msg) {
+    return (!(msg.content?.type === "action_result" &&
+        msg.metadata?.type === "action_result") &&
+        (msg.metadata?.type === "agent_response_message" ||
+            msg.metadata?.type === "user_message"));
+}
+async function getDialogueMessageCount(runtime, roomId) {
+    const messages = await runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        limit: 100,
+        unique: false,
+    });
+    let count = 0;
+    for (const msg of messages) {
+        if (isDialogueMessage(msg)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toStringArray(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+            .filter(Boolean);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    if (isRecord(value) && "point" in value) {
+        return toStringArray(value.point);
+    }
+    return [];
+}
+function parseSummaryResponse(text) {
+    const parsed = parseKeyValueXml(text);
+    if (parsed) {
+        const summary = typeof parsed.text === "string" && parsed.text.trim().length > 0
+            ? parsed.text.trim()
+            : "Summary not available";
+        const topics = toStringArray(parsed.topics);
+        const keyPoints = toStringArray(parsed.keyPoints);
+        if (summary !== "Summary not available" ||
+            topics.length > 0 ||
+            keyPoints.length > 0) {
+            return { summary, topics, keyPoints };
+        }
+    }
+    const summaryMatch = text.match(/<text>([\s\S]*?)<\/text>/);
+    const topicsMatch = text.match(/<topics>([\s\S]*?)<\/topics>/);
+    const keyPointsMatches = text.matchAll(/<point>([\s\S]*?)<\/point>/g);
+    return {
+        summary: summaryMatch ? summaryMatch[1].trim() : "Summary not available",
+        topics: topicsMatch
+            ? topicsMatch[1]
+                .split(",")
+                .map((t) => t.trim())
+                .filter(Boolean)
+            : [],
+        keyPoints: Array.from(keyPointsMatches).map((match) => match[1].trim()),
+    };
+}
+export const summarizationEvaluator = {
+    name: spec.name,
+    description: spec.description,
+    similes: spec.similes ? [...spec.similes] : [],
+    alwaysRun: spec.alwaysRun ?? true,
+    examples: (spec.examples ?? []),
+    validate: async (runtime, message) => {
+        if (!message.content?.text)
+            return false;
+        const memoryService = runtime.getService("memory");
+        if (!memoryService)
+            return false;
+        const config = memoryService.getConfig();
+        const currentDialogueCount = await getDialogueMessageCount(runtime, message.roomId);
+        const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
+        if (!existingSummary) {
+            return currentDialogueCount >= config.shortTermSummarizationThreshold;
+        }
+        const newDialogueCount = currentDialogueCount - existingSummary.lastMessageOffset;
+        return newDialogueCount >= config.shortTermSummarizationInterval;
+    },
+    handler: async (runtime, message) => {
+        const memoryService = runtime.getService("memory");
+        if (!memoryService) {
+            logger.error({ src: "evaluator:memory" }, "MemoryService not found");
+            return undefined;
+        }
+        const config = memoryService.getConfig();
+        const { roomId } = message;
+        try {
+            logger.info({ src: "evaluator:memory" }, `Starting summarization for room ${roomId}`);
+            const existingSummary = await memoryService.getCurrentSessionSummary(roomId);
+            const lastOffset = existingSummary?.lastMessageOffset || 0;
+            const allMessages = await runtime.getMemories({
+                tableName: "messages",
+                roomId,
+                limit: 1000,
+                unique: false,
+            });
+            const allDialogueMessages = allMessages.filter(isDialogueMessage);
+            const totalDialogueCount = allDialogueMessages.length;
+            const newDialogueCount = totalDialogueCount - lastOffset;
+            if (newDialogueCount === 0) {
+                logger.debug({ src: "evaluator:memory" }, "No new dialogue messages to summarize");
+                return undefined;
+            }
+            const maxNewMessages = config.summaryMaxNewMessages || 50;
+            const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
+            if (newDialogueCount > maxNewMessages) {
+                logger.warn({ src: "evaluator:memory" }, `Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available)`);
+            }
+            const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+            const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
+            if (newDialogueMessages.length === 0) {
+                logger.debug({ src: "evaluator:memory" }, "No new dialogue messages retrieved after filtering");
+                return undefined;
+            }
+            const formattedMessages = newDialogueMessages
+                .map((msg) => {
+                const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
+                return `${sender}: ${msg.content.text || "[non-text message]"}`;
+            })
+                .join("\n");
+            const state = await runtime.composeState(message);
+            let prompt;
+            let template;
+            if (existingSummary) {
+                template = updateSummarizationTemplate;
+                prompt = composePromptFromState({
+                    state: {
+                        ...state,
+                        existingSummary: existingSummary.summary,
+                        existingTopics: existingSummary.topics?.join(", ") || "None",
+                        newMessages: formattedMessages,
+                    },
+                    template,
+                });
+            }
+            else {
+                const initialMessages = sortedDialogueMessages
+                    .map((msg) => {
+                    const sender = msg.entityId === runtime.agentId
+                        ? runtime.character.name
+                        : "User";
+                    return `${sender}: ${msg.content.text || "[non-text message]"}`;
+                })
+                    .join("\n");
+                template = initialSummarizationTemplate;
+                prompt = composePromptFromState({
+                    state: { ...state, recentMessages: initialMessages },
+                    template,
+                });
+            }
+            const modelType = (config.summaryModelType ??
+                ModelType.TEXT_NANO);
+            const response = await runtime.useModel(modelType, {
+                prompt,
+                maxTokens: config.summaryMaxTokens || 2500,
+            });
+            const summaryResult = parseSummaryResponse(response);
+            logAdvancedMemoryTrajectory({
+                runtime,
+                message,
+                providerName: "MEMORY_SUMMARIZATION",
+                purpose: "evaluate",
+                data: {
+                    hasExistingSummary: !!existingSummary,
+                    processedDialogueMessages: newDialogueMessages.length,
+                    totalDialogueMessages: totalDialogueCount,
+                    topicCount: summaryResult.topics.length,
+                    keyPointCount: summaryResult.keyPoints.length,
+                },
+                query: {
+                    modelType: String(modelType),
+                    roomId,
+                },
+            });
+            logger.info({ src: "evaluator:memory" }, `${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
+            const newOffset = lastOffset + newDialogueMessages.length;
+            const firstMessage = newDialogueMessages[0];
+            const lastMessage = newDialogueMessages[newDialogueMessages.length - 1];
+            const startTime = existingSummary
+                ? existingSummary.startTime
+                : firstMessage?.createdAt && firstMessage.createdAt > 0
+                    ? new Date(firstMessage.createdAt)
+                    : new Date();
+            const endTime = lastMessage?.createdAt && lastMessage.createdAt > 0
+                ? new Date(lastMessage.createdAt)
+                : new Date();
+            if (existingSummary) {
+                await memoryService.updateSessionSummary(existingSummary.id, roomId, {
+                    summary: summaryResult.summary,
+                    messageCount: existingSummary.messageCount + newDialogueMessages.length,
+                    lastMessageOffset: newOffset,
+                    endTime,
+                    topics: summaryResult.topics,
+                    metadata: { keyPoints: summaryResult.keyPoints },
+                });
+                logger.info({ src: "evaluator:memory" }, `Updated summary for room ${roomId}: ${newDialogueMessages.length} messages processed`);
+            }
+            else {
+                await memoryService.storeSessionSummary({
+                    agentId: runtime.agentId,
+                    roomId,
+                    entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
+                    summary: summaryResult.summary,
+                    messageCount: totalDialogueCount,
+                    lastMessageOffset: totalDialogueCount,
+                    startTime,
+                    endTime,
+                    topics: summaryResult.topics,
+                    metadata: { keyPoints: summaryResult.keyPoints },
+                });
+                logger.info({ src: "evaluator:memory" }, `Created summary for room ${roomId}: ${totalDialogueCount} messages summarized`);
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error.message : String(error);
+            logger.error({ src: "evaluator:memory", err }, "Error during summarization");
+        }
+        return undefined;
+    },
+};

package/packages/typescript/src/features/advanced-memory/index.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from "../../types/index.ts";
+export { longTermExtractionEvaluator, summarizationEvaluator, } from "./evaluators/index.ts";
+export { contextSummaryProvider, longTermMemoryProvider, } from "./providers/index.ts";
+export * from "./schemas/index.ts";
+export { MemoryService } from "./services/memory-service.ts";
+export { type LongTermMemory, LongTermMemoryCategory, type MemoryConfig, type MemoryExtraction, type MemoryServiceTypeName, type SessionSummary, type SummaryResult, } from "./types.ts";
+/**
+ * Create the advanced-memory plugin.
+ *
+ * No database-specific arguments needed. MemoryService discovers a
+ * MemoryStorageProvider at runtime via runtime.getService("memoryStorage").
+ * If none is registered by a database plugin, storage-backed features
+ * gracefully disable.
+ */
+export declare function createAdvancedMemoryPlugin(): Plugin;
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/advanced-memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/advanced-memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAWnD,OAAO,EACN,2BAA2B,EAC3B,sBAAsB,GACtB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACN,sBAAsB,EACtB,sBAAsB,GACtB,MAAM,sBAAsB,CAAC;AAE9B,cAAc,oBAAoB,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EACN,KAAK,cAAc,EACnB,sBAAsB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,aAAa,GAClB,MAAM,YAAY,CAAC;AAEpB;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,CASnD"}

package/packages/typescript/src/features/advanced-memory/index.js

@@ -0,0 +1,26 @@
+import { longTermExtractionEvaluator, summarizationEvaluator, } from "./evaluators/index.js";
+import { contextSummaryProvider, longTermMemoryProvider, } from "./providers/index.js";
+import { MemoryService } from "./services/memory-service.js";
+export { longTermExtractionEvaluator, summarizationEvaluator, } from "./evaluators/index.js";
+export { contextSummaryProvider, longTermMemoryProvider, } from "./providers/index.js";
+// Export the abstract, backend-agnostic schema definitions
+export * from "./schemas/index.js";
+export { MemoryService } from "./services/memory-service.js";
+export { LongTermMemoryCategory, } from "./types.js";
+/**
+ * Create the advanced-memory plugin.
+ *
+ * No database-specific arguments needed. MemoryService discovers a
+ * MemoryStorageProvider at runtime via runtime.getService("memoryStorage").
+ * If none is registered by a database plugin, storage-backed features
+ * gracefully disable.
+ */
+export function createAdvancedMemoryPlugin() {
+    return {
+        name: "memory",
+        description: "Memory management with conversation summarization and long-term persistent memory",
+        services: [MemoryService],
+        evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
+        providers: [longTermMemoryProvider, contextSummaryProvider],
+    };
+}

package/packages/typescript/src/features/advanced-memory/prompts.d.ts

@@ -0,0 +1,2 @@
+export { initialSummarizationTemplate, longTermExtractionTemplate, updateSummarizationTemplate, } from "../../prompts.ts";
+//# sourceMappingURL=prompts.d.ts.map

package/packages/typescript/src/features/advanced-memory/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/advanced-memory/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,4BAA4B,EAC5B,0BAA0B,EAC1B,2BAA2B,GAC3B,MAAM,kBAAkB,CAAC"}

package/packages/typescript/src/features/advanced-memory/prompts.js

@@ -0,0 +1 @@
+export { initialSummarizationTemplate, longTermExtractionTemplate, updateSummarizationTemplate, } from "../../prompts.js";

package/packages/typescript/src/features/advanced-memory/providers/context-summary.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../../types/index.ts";
+export declare const contextSummaryProvider: Provider;
+//# sourceMappingURL=context-summary.d.ts.map

package/packages/typescript/src/features/advanced-memory/providers/context-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-summary.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-memory/providers/context-summary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAKjC,eAAO,MAAM,sBAAsB,EAAE,QAqGpC,CAAC"}

package/packages/typescript/src/features/advanced-memory/providers/context-summary.js

@@ -0,0 +1,85 @@
+import { logger } from "../../../logger.js";
+import { addHeader } from "../../../utils.js";
+import { logAdvancedMemoryTrajectory } from "../trajectory.js";
+export const contextSummaryProvider = {
+    name: "SUMMARIZED_CONTEXT",
+    description: "Provides summarized context from previous conversations",
+    position: 96,
+    get: async (runtime, message, _state) => {
+        try {
+            const memoryService = runtime.getService("memory");
+            const { roomId } = message;
+            if (!memoryService) {
+                return {
+                    data: {},
+                    values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+                    text: "",
+                };
+            }
+            const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
+            if (!currentSummary) {
+                logAdvancedMemoryTrajectory({
+                    runtime,
+                    message,
+                    providerName: "SUMMARIZED_CONTEXT",
+                    purpose: "session_summary",
+                    data: {
+                        summaryPresent: false,
+                        messageCount: 0,
+                        topicCount: 0,
+                    },
+                    query: {
+                        roomId,
+                    },
+                });
+                return {
+                    data: {},
+                    values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+                    text: "",
+                };
+            }
+            const messageRange = `${currentSummary.messageCount} messages`;
+            const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
+            let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})\n`;
+            summaryOnly += currentSummary.summary;
+            let summaryWithTopics = summaryOnly;
+            if (currentSummary.topics && currentSummary.topics.length > 0) {
+                summaryWithTopics += `\n*Topics: ${currentSummary.topics.join(", ")}*`;
+            }
+            const sessionSummaries = addHeader("# Conversation Summary", summaryOnly);
+            const sessionSummariesWithTopics = addHeader("# Conversation Summary", summaryWithTopics);
+            logAdvancedMemoryTrajectory({
+                runtime,
+                message,
+                providerName: "SUMMARIZED_CONTEXT",
+                purpose: "session_summary",
+                data: {
+                    summaryPresent: true,
+                    messageCount: currentSummary.messageCount,
+                    topicCount: currentSummary.topics?.length ?? 0,
+                },
+                query: {
+                    roomId,
+                },
+            });
+            return {
+                data: {
+                    summaryText: currentSummary.summary,
+                    messageCount: currentSummary.messageCount,
+                    topics: currentSummary.topics?.join(", ") || "",
+                },
+                values: { sessionSummaries, sessionSummariesWithTopics },
+                text: sessionSummariesWithTopics,
+            };
+        }
+        catch (error) {
+            const err = error instanceof Error ? error.message : String(error);
+            logger.error({ src: "provider:memory", err }, "Error in contextSummaryProvider");
+            return {
+                data: {},
+                values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+                text: "",
+            };
+        }
+    },
+};

package/packages/typescript/src/features/advanced-memory/providers/index.d.ts

@@ -0,0 +1,3 @@
+export { contextSummaryProvider } from "./context-summary.ts";
+export { longTermMemoryProvider } from "./long-term-memory.ts";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/advanced-memory/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-memory/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC"}

package/packages/typescript/src/features/advanced-memory/providers/index.js

@@ -0,0 +1,2 @@
+export { contextSummaryProvider } from "./context-summary.js";
+export { longTermMemoryProvider } from "./long-term-memory.js";

package/packages/typescript/src/features/advanced-memory/providers/long-term-memory.d.ts

@@ -0,0 +1,3 @@
+import type { Provider } from "../../../types/index.ts";
+export declare const longTermMemoryProvider: Provider;
+//# sourceMappingURL=long-term-memory.d.ts.map

package/packages/typescript/src/features/advanced-memory/providers/long-term-memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"long-term-memory.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-memory/providers/long-term-memory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,yBAAyB,CAAC;AAKjC,eAAO,MAAM,sBAAsB,EAAE,QA4GpC,CAAC"}