Update interfaces

Author: opieter-aws

strands-ts/src/agent/agent.ts

@@ -69,7 +69,7 @@ import type { AgentAsToolOptions } from './agent-as-tool.js'
 
 import type { z } from 'zod'
 import { MemoryManager } from '../memory/memory-manager.js'
-import type { MemoryManagerConfig } from '../memory/types.js'
+import type { MemoryManagerConfig } from '../memory/index.js'
 import { SessionManager } from '../session/session-manager.js'
 import { Tracer } from '../telemetry/tracer.js'
 import { Meter } from '../telemetry/meter.js'

strands-ts/src/index.ts

@@ -270,14 +270,12 @@ export type { ElicitationCallback, ElicitationContext } from './types/elicitatio
 // Memory management
 export { MemoryManager } from './memory/index.js'
 export type {
-  KnowledgeEntry,
-  KnowledgeStore,
+  MemoryEntry,
+  MemoryStore,
   SearchOptions,
   MemorySearchOptions,
   MemoryStoreOptions,
-  StoreConfig,
   MemoryToolConfig,
-  MemoryToolsConfig,
   MemoryManagerConfig,
 } from './memory/index.js'
 

strands-ts/src/memory/__tests__/memory-manager.test.ts

@@ -1,13 +1,19 @@
 import { describe, it, expect, vi } from 'vitest'
 import { Agent } from '../../agent/agent.js'
 import { MemoryManager } from '../memory-manager.js'
-import type { KnowledgeStore, KnowledgeEntry } from '../types.js'
-
-function createMockStore(entries: KnowledgeEntry[] = [], writable = false): KnowledgeStore {
-  const store: KnowledgeStore = {
-    search: vi.fn().mockResolvedValue(entries),
+import type { MemoryStore, MemoryEntry } from '../types.js'
+
+function createMockStore(
+  name: string,
+  options?: { entries?: MemoryEntry[]; writable?: boolean; description?: string; limit?: number }
+): MemoryStore {
+  const store: MemoryStore = {
+    name,
+    ...(options?.description && { description: options.description }),
+    ...(options?.limit != null && { limit: options.limit }),
+    search: vi.fn().mockResolvedValue(options?.entries ?? []),
   }
-  if (writable) {
+  if (options?.writable) {
     store.add = vi.fn().mockResolvedValue(undefined)
   }
   return store
@@ -20,77 +26,102 @@ describe('MemoryManager', () => {
     })
 
     it('creates instance with valid config', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
+      const mm = new MemoryManager({ stores: [createMockStore('test')] })
       expect(mm.name).toBe('strands:memory-manager')
     })
+
+    it('throws when storeToolConfig references non-existent store', () => {
+      expect(
+        () =>
+          new MemoryManager({
+            stores: [createMockStore('a')],
+            storeToolConfig: { stores: ['nonexistent'] },
+          })
+      ).toThrow("store 'nonexistent' not found")
+    })
+
+    it('throws when storeToolConfig targets no writable stores', () => {
+      expect(
+        () =>
+          new MemoryManager({
+            stores: [createMockStore('a')],
+            storeToolConfig: true,
+          })
+      ).toThrow('storeToolConfig targets no writable stores')
+    })
+
+    it('throws when storeToolConfig is true with multiple writable stores and no explicit stores', () => {
+      expect(
+        () =>
+          new MemoryManager({
+            stores: [createMockStore('a', { writable: true }), createMockStore('b', { writable: true })],
+            storeToolConfig: true,
+          })
+      ).toThrow('must specify `stores` when multiple writable stores are configured')
+    })
+
+    it('allows storeToolConfig true with single writable store', () => {
+      const mm = new MemoryManager({
+        stores: [createMockStore('a', { writable: true })],
+        storeToolConfig: true,
+      })
+      expect(mm.getTools().map((t) => t.name)).toContain('store_memory')
+    })
   })
 
   describe('getTools', () => {
     it('registers search tool by default', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
+      const mm = new MemoryManager({ stores: [createMockStore('test')] })
       const tools = mm.getTools()
       expect(tools).toHaveLength(1)
       expect(tools[0]!.name).toBe('search_memory')
     })
 
-    it('registers both search and store tools when a writable store exists', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore([], true) }] })
+    it('registers store tool when storeToolConfig is enabled', () => {
+      const mm = new MemoryManager({
+        stores: [createMockStore('test', { writable: true })],
+        storeToolConfig: true,
+      })
       const tools = mm.getTools()
-      expect(tools).toHaveLength(2)
       expect(tools.map((t) => t.name)).toStrictEqual(['search_memory', 'store_memory'])
     })
 
-    it('does not register store tool when no writable stores exist', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
+    it('does not register store tool by default', () => {
+      const mm = new MemoryManager({ stores: [createMockStore('test', { writable: true })] })
       const tools = mm.getTools()
       expect(tools.map((t) => t.name)).toStrictEqual(['search_memory'])
     })
 
-    it('returns empty array when includeTools is false', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore([], true) }], includeTools: false })
-      expect(mm.getTools()).toStrictEqual([])
-    })
-
-    it('respects ToolsConfig to disable search', () => {
-      const mm = new MemoryManager({
-        stores: [{ store: createMockStore([], true) }],
-        includeTools: { search: false },
-      })
-      const tools = mm.getTools()
-      expect(tools.map((t) => t.name)).toStrictEqual(['store_memory'])
-    })
-
-    it('respects ToolsConfig to disable store', () => {
+    it('returns empty array when searchToolConfig is false and storeToolConfig is false', () => {
       const mm = new MemoryManager({
-        stores: [{ store: createMockStore([], true) }],
-        includeTools: { store: false },
+        stores: [createMockStore('test', { writable: true })],
+        searchToolConfig: false,
+        storeToolConfig: false,
       })
-      const tools = mm.getTools()
-      expect(tools.map((t) => t.name)).toStrictEqual(['search_memory'])
+      expect(mm.getTools()).toStrictEqual([])
     })
 
-    it('uses custom tool names from MemoryToolsConfig', () => {
+    it('uses custom tool names from MemoryToolConfig', () => {
       const mm = new MemoryManager({
-        stores: [{ store: createMockStore([], true) }],
-        includeTools: { search: { name: 'recall' }, store: { name: 'remember' } },
+        stores: [createMockStore('test', { writable: true })],
+        searchToolConfig: { name: 'recall' },
+        storeToolConfig: { name: 'remember', stores: ['test'] },
       })
       const tools = mm.getTools()
       expect(tools.map((t) => t.name)).toStrictEqual(['recall', 'remember'])
     })
 
-    it('includes store descriptions in search tool description when stores are named', () => {
-      const mm = new MemoryManager({
-        stores: [{ store: createMockStore(), name: 'personal', description: 'User preferences' }],
-      })
+    it('includes store descriptions in search tool description', () => {
+      const store = createMockStore('personal', { description: 'User preferences' })
+      const mm = new MemoryManager({ stores: [store] })
       const tools = mm.getTools()
       expect(tools[0]!.description).toContain('personal: User preferences')
       expect(tools[0]!.description).toContain('target one or more memory stores by name')
     })
 
-    it('includes store descriptions in store tool description when writable stores are named', () => {
-      const mm = new MemoryManager({
-        stores: [{ store: createMockStore([], true), name: 'notes', description: 'Personal notes' }],
-      })
+    it('includes store descriptions in store tool description', () => {
+      const store = createMockStore('notes', { writable: true, description: 'Personal notes' })
+      const mm = new MemoryManager({ stores: [store], storeToolConfig: true })
       const tools = mm.getTools()
       const storeTool = tools.find((t) => t.name === 'store_memory')!
       expect(storeTool.description).toContain('notes: Personal notes')
@@ -100,150 +131,133 @@ describe('MemoryManager', () => {
 
   describe('search', () => {
     it('queries all stores and concatenates results', async () => {
-      const store1 = createMockStore([{ id: '1', content: 'fact one' }])
-      const store2 = createMockStore([{ id: '2', content: 'fact two' }])
-      const mm = new MemoryManager({ stores: [{ store: store1 }, { store: store2 }] })
+      const store1 = createMockStore('a', { entries: [{ content: 'fact one' }] })
+      const store2 = createMockStore('b', { entries: [{ content: 'fact two' }] })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       const results = await mm.search('query')
-      expect(results).toStrictEqual([
-        { id: '1', content: 'fact one' },
-        { id: '2', content: 'fact two' },
-      ])
+      expect(results).toStrictEqual([{ content: 'fact one' }, { content: 'fact two' }])
     })
 
     it('passes limit to each store', async () => {
-      const store = createMockStore()
-      const mm = new MemoryManager({ stores: [{ store, limit: 5 }] })
+      const store = createMockStore('a', { limit: 5 })
+      const mm = new MemoryManager({ stores: [store] })
 
       await mm.search('query')
       expect(store.search).toHaveBeenCalledWith('query', { limit: 5 })
     })
 
     it('overrides per-store limit with options.limit', async () => {
-      const store = createMockStore()
-      const mm = new MemoryManager({ stores: [{ store, limit: 5 }] })
+      const store = createMockStore('a', { limit: 5 })
+      const mm = new MemoryManager({ stores: [store] })
 
-      await mm.search('query', { limit: 3 })
-      expect(store.search).toHaveBeenCalledWith('query', { limit: 3 })
+      await mm.search('query', { limit: 2 })
+      expect(store.search).toHaveBeenCalledWith('query', { limit: 2 })
     })
 
-    it('defaults to limit of 10 when no limit configured', async () => {
-      const store = createMockStore()
-      const mm = new MemoryManager({ stores: [{ store }] })
+    it('defaults to limit of 3 when no limit configured', async () => {
+      const store = createMockStore('a')
+      const mm = new MemoryManager({ stores: [store] })
 
       await mm.search('query')
-      expect(store.search).toHaveBeenCalledWith('query', { limit: 10 })
+      expect(store.search).toHaveBeenCalledWith('query', { limit: 3 })
     })
 
     it('filters to named stores when options.stores is provided', async () => {
-      const store1 = createMockStore([{ id: '1', content: 'personal fact' }])
-      const store2 = createMockStore([{ id: '2', content: 'team fact' }])
-      const mm = new MemoryManager({
-        stores: [
-          { store: store1, name: 'personal' },
-          { store: store2, name: 'team' },
-        ],
-      })
+      const store1 = createMockStore('personal', { entries: [{ content: 'personal fact' }] })
+      const store2 = createMockStore('team', { entries: [{ content: 'team fact' }] })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       const results = await mm.search('query', { stores: ['personal'] })
-      expect(results).toStrictEqual([{ id: '1', content: 'personal fact' }])
+      expect(results).toStrictEqual([{ content: 'personal fact' }])
       expect(store2.search).not.toHaveBeenCalled()
     })
 
     it('gracefully handles store failures', async () => {
-      const store1: KnowledgeStore = { search: vi.fn().mockRejectedValue(new Error('network error')) }
-      const store2 = createMockStore([{ id: '2', content: 'fact' }])
-      const mm = new MemoryManager({ stores: [{ store: store1 }, { store: store2 }] })
+      const store1: MemoryStore = { name: 'failing', search: vi.fn().mockRejectedValue(new Error('network error')) }
+      const store2 = createMockStore('ok', { entries: [{ content: 'fact' }] })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       const results = await mm.search('query')
-      expect(results).toStrictEqual([{ id: '2', content: 'fact' }])
+      expect(results).toStrictEqual([{ content: 'fact' }])
     })
   })
 
   describe('store', () => {
     it('writes to all writable stores', async () => {
-      const store1 = createMockStore([], true)
-      const store2 = createMockStore([], true)
-      const mm = new MemoryManager({ stores: [{ store: store1 }, { store: store2 }] })
+      const store1 = createMockStore('a', { writable: true })
+      const store2 = createMockStore('b', { writable: true })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       await mm.store('user likes coffee')
       expect(store1.add).toHaveBeenCalledWith('user likes coffee', undefined)
       expect(store2.add).toHaveBeenCalledWith('user likes coffee', undefined)
     })
 
     it('passes metadata to stores', async () => {
-      const store = createMockStore([], true)
-      const mm = new MemoryManager({ stores: [{ store }] })
+      const store = createMockStore('a', { writable: true })
+      const mm = new MemoryManager({ stores: [store] })
 
       await mm.store('fact', { metadata: { source: 'user' } })
       expect(store.add).toHaveBeenCalledWith('fact', { source: 'user' })
     })
 
     it('filters to named stores when options.stores is provided', async () => {
-      const store1 = createMockStore([], true)
-      const store2 = createMockStore([], true)
-      const mm = new MemoryManager({
-        stores: [
-          { store: store1, name: 'personal' },
-          { store: store2, name: 'team' },
-        ],
-      })
+      const store1 = createMockStore('personal', { writable: true })
+      const store2 = createMockStore('team', { writable: true })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       await mm.store('my preference', { stores: ['personal'] })
       expect(store1.add).toHaveBeenCalledWith('my preference', undefined)
       expect(store2.add).not.toHaveBeenCalled()
     })
 
-    it('throws when no writable stores are configured', async () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
-      await expect(mm.store('fact')).rejects.toThrow('no writable store configured')
-    })
-
-    it('throws when named stores filter matches no writable stores', async () => {
-      const store = createMockStore([], true)
-      const mm = new MemoryManager({ stores: [{ store, name: 'personal' }] })
-      await expect(mm.store('fact', { stores: ['nonexistent'] })).rejects.toThrow('no writable store configured')
+    it('throws when no writable stores match', async () => {
+      const mm = new MemoryManager({ stores: [createMockStore('a')] })
+      await expect(mm.store('fact')).rejects.toThrow('no writable store matched')
     })
 
     it('succeeds with partial write failures (some stores fail, some succeed)', async () => {
-      const store1: KnowledgeStore = {
+      const store1: MemoryStore = {
+        name: 'failing',
         search: vi.fn().mockResolvedValue([]),
         add: vi.fn().mockRejectedValue(new Error('write error')),
       }
-      const store2 = createMockStore([], true)
-      const mm = new MemoryManager({ stores: [{ store: store1 }, { store: store2 }] })
+      const store2 = createMockStore('ok', { writable: true })
+      const mm = new MemoryManager({ stores: [store1, store2] })
 
       await mm.store('fact')
       expect(store2.add).toHaveBeenCalledWith('fact', undefined)
     })
 
     it('throws AggregateError when all writes fail', async () => {
-      const store: KnowledgeStore = {
+      const store: MemoryStore = {
+        name: 'failing',
         search: vi.fn().mockResolvedValue([]),
         add: vi.fn().mockRejectedValue(new Error('write error')),
       }
-      const mm = new MemoryManager({ stores: [{ store }] })
+      const mm = new MemoryManager({ stores: [store] })
 
       await expect(mm.store('fact')).rejects.toThrow('all store writes failed')
     })
   })
 
   describe('initAgent', () => {
     it('does not throw', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
+      const mm = new MemoryManager({ stores: [createMockStore('test')] })
       expect(() => mm.initAgent({} as any)).not.toThrow()
     })
   })
 
   describe('AgentConfig integration', () => {
     it('auto-wraps MemoryManagerConfig into MemoryManager instance', () => {
-      const store = createMockStore()
-      const agent = new Agent({ memoryManager: { stores: [{ store }] } })
+      const store = createMockStore('test')
+      const agent = new Agent({ memoryManager: { stores: [store] } })
       expect(agent.memoryManager).toBeInstanceOf(MemoryManager)
     })
 
     it('passes through MemoryManager instance unchanged', () => {
-      const mm = new MemoryManager({ stores: [{ store: createMockStore() }] })
+      const mm = new MemoryManager({ stores: [createMockStore('test')] })
       const agent = new Agent({ memoryManager: mm })
       expect(agent.memoryManager).toBe(mm)
     })