FilesExpand file tree

main

/

summary-store.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

98 lines (90 loc) · 3.21 KB

main

/

summary-store.ts

Copy path

Top

File metadata and controls

• Code
• Blame

98 lines (90 loc) · 3.21 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

import { dbFor } from '@sim/db'

import { memory } from '@sim/db/schema'

import { isRecordLike } from '@sim/utils/object'

import { and, eq, isNull, sql } from 'drizzle-orm'

import { decryptSecret, encryptSecret } from '@/lib/core/security/encryption'

export const MAX_MEMORY_SUMMARY_CHARS = 6000

const MAX_ENCRYPTED_SUMMARY_BYTES = 64 * 1024

export interface MemorySummaryScope {

workspaceId: string

memoryId: string

}

export interface MemoryContextSummary {

sourceHash: string

/** Number of original canonical messages in the summarized prefix. */

sourceMessageCount: number

content: string

}

export interface SaveMemorySummaryInput extends MemorySummaryScope, MemoryContextSummary {}

function predicate(scope: MemorySummaryScope) {

return and(

eq(memory.id, scope.memoryId),

eq(memory.workspaceId, scope.workspaceId),

isNull(memory.deletedAt)

)

}

function validateHash(hash: string): void {

if (!/^[a-f0-9]{64}$/.test(hash)) throw new Error('Invalid memory summary source hash')

}

/** Returns scoped cache metadata; the context selector must verify its complete eligible prefix hash. */

export async function readMemorySummary(

scope: MemorySummaryScope

): Promise<MemoryContextSummary | undefined> {

const [row] = await dbFor('exec')

.select({

value: sql<

string | null

>`CASE WHEN octet_length(${memory.encryptedContextSummary}) <= ${MAX_ENCRYPTED_SUMMARY_BYTES} THEN ${memory.encryptedContextSummary} ELSE NULL END`,

})

.from(memory)

.where(predicate(scope))

.limit(1)

if (!row?.value) return undefined

const { decrypted } = await decryptSecret(row.value, { logFailure: false })

const value: unknown = JSON.parse(decrypted)

if (

!isRecordLike(value) ||

value.version !== 2 ||

value.memoryId !== scope.memoryId ||

typeof value.sourceHash !== 'string' ||

!/^[a-f0-9]{64}$/.test(value.sourceHash) ||

typeof value.sourceMessageCount !== 'number' ||

!Number.isSafeInteger(value.sourceMessageCount) ||

value.sourceMessageCount < 1 ||

typeof value.content !== 'string' ||

!value.content.trim() ||

value.content.length > MAX_MEMORY_SUMMARY_CHARS

)

return undefined

return {

content: value.content,

sourceHash: value.sourceHash,

sourceMessageCount: value.sourceMessageCount,

}

}

/** A single guarded row update replaces the cache without touching conversation data or provenance. */

export async function saveMemorySummary(input: SaveMemorySummaryInput): Promise<void> {

validateHash(input.sourceHash)

if (

!input.content.trim() ||

input.content.length > MAX_MEMORY_SUMMARY_CHARS ||

!Number.isSafeInteger(input.sourceMessageCount) ||

input.sourceMessageCount < 1

)

throw new Error('Invalid memory summary')

const { encrypted } = await encryptSecret(

JSON.stringify({

version: 2,

memoryId: input.memoryId,

sourceHash: input.sourceHash,

sourceMessageCount: input.sourceMessageCount,

content: input.content,

})

)

if (Buffer.byteLength(encrypted, 'utf8') > MAX_ENCRYPTED_SUMMARY_BYTES)

throw new Error('Memory summary exceeds its storage limit')

await dbFor('exec')

.update(memory)

.set({ encryptedContextSummary: encrypted })

.where(predicate(input))

}