refactor: Remove getCachedMessages and getMessagesByImportance methods

- Remove getCachedMessages from MemoryStorage interface, InMemoryStorage, and Memory class
- Remove getMessagesByImportance from MemoryStorage interface, InMemoryStorage, and Memory class
- Remove related tests (3 tests removed, 17 tests remaining, all passing)
- Update usage examples to remove references to removed methods
- Build successful with no TypeScript errors

Author: mattapperson

examples/memory-usage.ts

@@ -195,13 +195,11 @@ async function main() {
     cacheControl: { enabled: true, expiresAt: futureDate },
   });
 
-  const cachedMsgs = await memory.getCachedMessages(cacheThreadId);
-  console.log(`Cached messages: ${cachedMsgs.length}`);
+  console.log(`Cache control enabled for message: ${cacheMsg.id}`);
 
   // Invalidate cache when needed
   await memory.invalidateCache(cacheThreadId);
-  const cachedAfterInvalidate = await memory.getCachedMessages(cacheThreadId);
-  console.log(`Cached messages after invalidation: ${cachedAfterInvalidate.length}`);
+  console.log(`Cache invalidated for thread: ${cacheThreadId}`);
 
   // Example 12: Message filtering by status and importance
   console.log("\n=== Example 12: Message Filtering ===");
@@ -235,10 +233,6 @@ async function main() {
 
   const archivedMsgs = await memory.getMessagesByStatus(filterThreadId, "archived");
   console.log(`Archived messages: ${archivedMsgs.length}`);
-
-  // Filter by importance
-  const importantMsgs = await memory.getMessagesByImportance(filterThreadId, 0.7);
-  console.log(`Messages with importance >= 0.7: ${importantMsgs.length}`);
 }
 
 main().catch(console.error);

src/lib/memory/memory.ts

@@ -344,19 +344,6 @@ export class Memory {
 
   // ===== Cache Management =====
 
-  /**
-   * Get messages with active cache
-   * @param threadId The thread ID
-   * @returns Array of cached messages, or empty if storage doesn't support caching
-   */
-  async getCachedMessages(threadId: string): Promise<MemoryMessage[]> {
-    if (!this.storage.getCachedMessages) {
-      return [];
-    }
-
-    return await this.storage.getCachedMessages(threadId);
-  }
-
   /**
    * Invalidate cache for messages
    * @param threadId The thread ID
@@ -391,27 +378,6 @@ export class Memory {
     return await this.storage.getMessagesByStatus(threadId, status);
   }
 
-  /**
-   * Get messages by importance threshold
-   * @param threadId The thread ID
-   * @param minImportance Minimum importance score (0-1)
-   * @returns Array of messages meeting importance threshold
-   */
-  async getMessagesByImportance(
-    threadId: string,
-    minImportance: number,
-  ): Promise<MemoryMessage[]> {
-    if (!this.storage.getMessagesByImportance) {
-      // Fall back to getting all messages and filtering
-      const all = await this.storage.getMessages(threadId);
-      return all.filter(
-        (m) => m.importance !== undefined && m.importance >= minImportance,
-      );
-    }
-
-    return await this.storage.getMessagesByImportance(threadId, minImportance);
-  }
-
   // ===== Utility Methods =====
 
   /**

src/lib/memory/storage/in-memory.ts

@@ -364,17 +364,6 @@ export class InMemoryStorage implements MemoryStorage {
 
   // ===== Cache Management Operations =====
 
-  async getCachedMessages(threadId: string): Promise<MemoryMessage[]> {
-    const messages = await this.getMessages(threadId);
-    const now = new Date();
-
-    return messages.filter((msg) => {
-      if (!msg.cacheControl?.enabled) return false;
-      if (!msg.cacheControl.expiresAt) return true;
-      return msg.cacheControl.expiresAt > now;
-    });
-  }
-
   async invalidateCache(threadId: string, beforeDate?: Date): Promise<void> {
     const messages = await this.getMessages(threadId);
     const cutoff = beforeDate || new Date();
@@ -404,14 +393,4 @@ export class InMemoryStorage implements MemoryStorage {
     const messages = await this.getMessages(threadId);
     return messages.filter((m) => m.status === status);
   }
-
-  async getMessagesByImportance(
-    threadId: string,
-    minImportance: number,
-  ): Promise<MemoryMessage[]> {
-    const messages = await this.getMessages(threadId);
-    return messages.filter(
-      (m) => m.importance !== undefined && m.importance >= minImportance,
-    );
-  }
 }

src/lib/memory/storage/interface.ts

@@ -205,13 +205,6 @@ export interface MemoryStorage {
 
   // ===== Cache Management Operations (Optional) =====
 
-  /**
-   * Get messages with active cache
-   * @param threadId The thread ID
-   * @returns Array of cached messages
-   */
-  getCachedMessages?(threadId: string): Promise<MemoryMessage[]>;
-
   /**
    * Invalidate cache for messages
    * @param threadId The thread ID
@@ -231,15 +224,4 @@ export interface MemoryStorage {
     threadId: string,
     status: string,
   ): Promise<MemoryMessage[]>;
-
-  /**
-   * Get messages by importance threshold
-   * @param threadId The thread ID
-   * @param minImportance Minimum importance score (0-1)
-   * @returns Array of messages meeting importance threshold
-   */
-  getMessagesByImportance?(
-    threadId: string,
-    minImportance: number,
-  ): Promise<MemoryMessage[]>;
 }

tests/e2e/memory.test.ts

@@ -257,50 +257,6 @@ describe("Memory Integration E2E Tests", () => {
       expect(messages.length).toBeLessThanOrEqual(4);
     });
 
-    it("should manage cache control for messages", async () => {
-      await memory.createThread("thread-1", "user-1");
-
-      const saved = await memory.saveMessages("thread-1", "user-1", [
-        { role: "user" as const, content: "Cached message" },
-        { role: "assistant" as const, content: "Not cached" },
-      ]);
-
-      // Enable cache for first message
-      const futureDate = new Date(Date.now() + 60000); // 1 minute from now
-      await storage.updateMessage(saved[0].id, {
-        cacheControl: { enabled: true, expiresAt: futureDate },
-      });
-
-      const cachedMessages = await memory.getCachedMessages("thread-1");
-      expect(cachedMessages).toHaveLength(1);
-      expect(cachedMessages[0].message.content).toBe("Cached message");
-    });
-
-    it("should invalidate cache for messages", async () => {
-      await memory.createThread("thread-1", "user-1");
-
-      const saved = await memory.saveMessages("thread-1", "user-1", [
-        { role: "user" as const, content: "Cached message" },
-      ]);
-
-      // Enable cache
-      const futureDate = new Date(Date.now() + 60000);
-      await storage.updateMessage(saved[0].id, {
-        cacheControl: { enabled: true, expiresAt: futureDate },
-      });
-
-      // Verify cache is active
-      let cachedMessages = await memory.getCachedMessages("thread-1");
-      expect(cachedMessages).toHaveLength(1);
-
-      // Invalidate cache
-      await memory.invalidateCache("thread-1");
-
-      // Verify cache is invalidated
-      cachedMessages = await memory.getCachedMessages("thread-1");
-      expect(cachedMessages).toHaveLength(0);
-    });
-
     it("should filter messages by status", async () => {
       await memory.createThread("thread-1", "user-1");
 
@@ -324,27 +280,6 @@ describe("Memory Integration E2E Tests", () => {
       expect(archivedMessages[0].message.content).toBe("Archived message");
     });
 
-    it("should filter messages by importance threshold", async () => {
-      await memory.createThread("thread-1", "user-1");
-
-      const saved = await memory.saveMessages("thread-1", "user-1", [
-        { role: "user" as const, content: "Low importance" },
-        { role: "assistant" as const, content: "Medium importance" },
-        { role: "user" as const, content: "High importance" },
-      ]);
-
-      // Set importance scores
-      await storage.updateMessage(saved[0].id, { importance: 0.3 });
-      await storage.updateMessage(saved[1].id, { importance: 0.6 });
-      await storage.updateMessage(saved[2].id, { importance: 0.9 });
-
-      // Get messages with importance >= 0.5
-      const importantMessages = await memory.getMessagesByImportance("thread-1", 0.5);
-      expect(importantMessages).toHaveLength(2);
-      expect(importantMessages[0].importance).toBeGreaterThanOrEqual(0.5);
-      expect(importantMessages[1].importance).toBeGreaterThanOrEqual(0.5);
-    });
-
     it("should handle graceful degradation when storage doesn't support features", async () => {
       // Create a storage that doesn't implement optional methods
       class BasicStorage extends InMemoryStorage {