feat: add conversation cache and session persistence

src/assistant/sessionHistory.ts

@@ -3,15 +3,36 @@ import { getOauthConfig } from '../constants/oauth.js'
 import type { SDKMessage } from '../entrypoints/agentSdkTypes.js'
 import { logForDebugging } from '../utils/debug.js'
 import { getOAuthHeaders, prepareApiRequest } from '../utils/teleport/api.js'
+import {
+  ConversationCache,
+  createConversationCache,
+  type CacheMessage,
+} from '../utils/conversationCache.js'
+import {
+  saveSession,
+  loadSession,
+  listSessions,
+  createSession,
+} from '../utils/sessionPersistence.js'
 
 export const HISTORY_PAGE_SIZE = 100
 
+// Module-level cache for session history
+let historyCache: ConversationCache | undefined
+
+function getHistoryCache(): ConversationCache {
+  if (!historyCache) {
+    historyCache = createConversationCache({
+      maxSize: 50,
+      ttlMs: 60 * 60 * 1000, // 1 hour
+    })
+  }
+  return historyCache
+}
+
 export type HistoryPage = {
-  /** Chronological order within the page. */
   events: SDKMessage[]
-  /** Oldest event ID in this page → before_id cursor for next-older page. */
   firstId: string | null
-  /** true = older events exist. */
   hasMore: boolean
 }
 
@@ -27,7 +48,6 @@ export type HistoryAuthCtx = {
   headers: Record<string, string>
 }
 
-/** Prepare auth + headers + base URL once, reuse across pages. */
 export async function createHistoryAuthCtx(
   sessionId: string,
 ): Promise<HistoryAuthCtx> {
@@ -66,22 +86,99 @@ async function fetchPage(
   }
 }
 
-/**
- * Newest page: last `limit` events, chronological, via anchor_to_latest.
- * has_more=true means older events exist.
- */
+function extractSessionId(baseUrl: string): string {
+  const match = baseUrl.split('/v1/sessions/')[1]
+  return match ? match.split('/')[0] : 'default'
+}
+
+function serializeToCacheMessage(events: SDKMessage[]): CacheMessage[] {
+  return events.map((m): CacheMessage => ({
+    role: m.role,
+    content:
+      typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+    tool_calls: m.tool_calls as CacheMessage['tool_calls'],
+    tool_use_id: m.tool_use_id,
+  }))
+}
+
+function deserializeFromCacheMessage(messages: CacheMessage[]): SDKMessage[] {
+  return messages.map((m): SDKMessage => ({
+    role: m.role,
+    content: m.content,
+    tool_calls: m.tool_calls as SDKMessage['tool_calls'],
+    tool_use_id: m.tool_use_id,
+  }))
+}
+
 export async function fetchLatestEvents(
   ctx: HistoryAuthCtx,
   limit = HISTORY_PAGE_SIZE,
 ): Promise<HistoryPage | null> {
-  return fetchPage(ctx, { limit, anchor_to_latest: true }, 'fetchLatestEvents')
+  const sessionId = extractSessionId(ctx.baseUrl)
+
+  // Check cache first before fetching from API
+  const cached = await loadCachedSession(sessionId)
+  if (cached) {
+    return {
+      events: cached,
+      firstId: null,
+      hasMore: true,
+    }
+  }
+
+  const page = await fetchPage(ctx, { limit, anchor_to_latest: true }, 'fetchLatestEvents')
+
+  if (page && page.events.length > 0) {
+    // Cache and persist the fetched events
+    await cacheSession(sessionId, page.events)
+  }
+
+  return page
 }
 
-/** Older page: events immediately before `beforeId` cursor. */
 export async function fetchOlderEvents(
   ctx: HistoryAuthCtx,
   beforeId: string,
   limit = HISTORY_PAGE_SIZE,
 ): Promise<HistoryPage | null> {
   return fetchPage(ctx, { limit, before_id: beforeId }, 'fetchOlderEvents')
 }
+
+export async function cacheSession(
+  sessionId: string,
+  events: SDKMessage[],
+): Promise<void> {
+  const cache = getHistoryCache()
+  const messages = serializeToCacheMessage(events)
+  cache.set(sessionId, messages)
+
+  const session = createSession(
+    messages as any,
+    { model: process.env.OPENAI_MODEL },
+  )
+  session.id = sessionId
+  await saveSession(session)
+}
+
+export async function loadCachedSession(
+  sessionId: string,
+): Promise<SDKMessage[] | null> {
+  const cache = getHistoryCache()
+  const cached = cache.get(sessionId)
+  if (cached) {
+    return deserializeFromCacheMessage(cached)
+  }
+
+  try {
+    const session = await loadSession(sessionId)
+    if (session) {
+      const events = session.messages as CacheMessage[]
+      cache.set(sessionId, events)
+      return deserializeFromCacheMessage(events)
+    }
+  } catch {
+    // Session not found or corrupt
+  }
+
+  return null
+}

src/utils/conversationCache.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, it, beforeEach } from 'bun:test'
+import { createConversationCache, type Message } from './conversationCache.js'
+
+describe('conversationCache', () => {
+  let cache: ReturnType<typeof createConversationCache>
+
+  beforeEach(() => {
+    cache = createConversationCache({ maxSize: 3, ttlMs: 60000 })
+  })
+
+  describe('basic operations', () => {
+    it('stores and retrieves messages', () => {
+      const messages: Message[] = [
+        { role: 'user', content: 'hello' },
+      ]
+      cache.set('session1', messages)
+      expect(cache.get('session1')).toEqual(messages)
+    })
+
+    it('returns undefined for missing key', () => {
+      expect(cache.get('nonexistent')).toBeUndefined()
+    })
+
+    it('reports correct size', () => {
+      cache.set('a', [{ role: 'user', content: 'a' }])
+      cache.set('b', [{ role: 'user', content: 'b' }])
+      expect(cache.size).toBe(2)
+    })
+  })
+
+  describe('LRU eviction', () => {
+    it('evicts oldest when at capacity', () => {
+      cache.set('a', [{ role: 'user', content: 'a' }])
+      cache.set('b', [{ role: 'user', content: 'b' }])
+      cache.set('c', [{ role: 'user', content: 'c' }])
+      cache.set('d', [{ role: 'user', content: 'd' }]) // should evict 'a'
+
+      expect(cache.get('a')).toBeUndefined()
+      expect(cache.get('d')).toBeDefined()
+    })
+
+    it('updates access order on get', () => {
+      cache.set('a', [{ role: 'user', content: 'a' }])
+      cache.set('b', [{ role: 'user', content: 'b' }])
+      cache.get('a') // access 'a' to update order
+      cache.set('c', [{ role: 'user', content: 'c' }])
+      cache.set('d', [{ role: 'user', content: 'd' }]) // should evict 'b'
+
+      expect(cache.get('b')).toBeUndefined()
+      expect(cache.get('a')).toBeDefined()
+    })
+  })
+
+  describe('TTL expiration', () => {
+    it('evicts expired entries', async () => {
+      const shortCache = createConversationCache({ ttlMs: 1 })
+      shortCache.set('x', [{ role: 'user', content: 'x' }])
+
+      await new Promise(r => setTimeout(r, 10))
+
+      expect(shortCache.get('x')).toBeUndefined()
+    })
+  })
+
+  describe('delete and clear', () => {
+    it('deletes specific key', () => {
+      cache.set('a', [{ role: 'user', content: 'a' }])
+      expect(cache.delete('a')).toBe(true)
+      expect(cache.get('a')).toBeUndefined()
+    })
+
+    it('clears all entries', () => {
+      cache.set('a', [{ role: 'user', content: 'a' }])
+      cache.set('b', [{ role: 'user', content: 'b' }])
+      cache.clear()
+      expect(cache.size).toBe(0)
+    })
+  })
+})