fix(tables): keep oversized memory rows pageable

Author: kerrylu

apps/sim/lib/virtual-tables/memory-virtual-table.server.test.ts

@@ -333,7 +333,7 @@ describe('Memory virtual table', () => {
     expect(result.hasMore).toBe(true)
   })
 
-  it('rejects a transcript that alone exceeds the query byte budget', async () => {
+  it('returns bounded metadata without loading a transcript that exceeds the query byte budget', async () => {
     const oversized = {
       id: 'memory-1',
       key: 'conversation-1',
@@ -344,14 +344,24 @@ describe('Memory virtual table', () => {
       rowBytes: 5 * 1024 * 1024 + 1,
     }
     queueTableRows(schemaMock.memory, [oversized])
-    await expect(
-      queryMemoryTableRows({
-        workspaceId: 'workspace-1',
-        limit: 1000,
-        includeTotal: false,
-      })
-    ).rejects.toThrow('Memory transcript exceeds the 5MB table query limit')
+    const result = await queryMemoryTableRows({
+      workspaceId: 'workspace-1',
+      limit: 1000,
+      includeTotal: false,
+    })
 
+    expect(result.rows).toEqual([
+      expect.objectContaining({
+        id: oversized.id,
+        data: expect.objectContaining({
+          transcript: {
+            omitted: true,
+            reason: 'Transcript exceeds the 5MB table query limit',
+          },
+        }),
+      }),
+    ])
+    expect(result.hasMore).toBe(false)
     expect(dbChainMockFns.select).toHaveBeenCalledTimes(2)
   })
 

apps/sim/lib/virtual-tables/memory-virtual-table.server.ts

@@ -204,6 +204,11 @@ export async function queryMemoryTableRows({
     getMaxPageBytes() ?? TABLE_LIMITS.MAX_QUERY_RESULT_BYTES,
     TABLE_LIMITS.MAX_QUERY_RESULT_BYTES
   )
+  const omittedTranscript: JsonValue = {
+    omitted: true,
+    reason: `Transcript exceeds the ${Math.floor(pageByteBudget / (1024 * 1024))}MB table query limit`,
+  }
+  const oversizedTranscriptIds = new Set<string>()
   const selectedCandidates: typeof candidates = []
   let selectedBytes = 0
   let hasMore = candidates.length === limit
@@ -213,21 +218,24 @@ export async function queryMemoryTableRows({
     if (!Number.isFinite(rowBytes) || rowBytes < 0) {
       throw new TableQueryValidationError('Memory table returned an invalid row size')
     }
+    let outputRowBytes = rowBytes
     if (rowBytes > pageByteBudget) {
-      throw new TableQueryValidationError(
-        `Memory transcript exceeds the ${Math.floor(pageByteBudget / (1024 * 1024))}MB table query limit`,
-        'TABLE_QUERY_RESULT_TOO_LARGE'
+      oversizedTranscriptIds.add(candidate.id)
+      outputRowBytes = Buffer.byteLength(
+        JSON.stringify(mapMemoryRecordToTableRow({ ...candidate, data: omittedTranscript }).data)
       )
     }
-    if (selectedCandidates.length > 0 && selectedBytes + rowBytes > pageByteBudget) {
+    if (selectedCandidates.length > 0 && selectedBytes + outputRowBytes > pageByteBudget) {
       hasMore = true
       break
     }
     selectedCandidates.push(candidate)
-    selectedBytes += rowBytes
+    selectedBytes += outputRowBytes
   }
 
-  const selectedIds = selectedCandidates.map((candidate) => candidate.id)
+  const selectedIds = selectedCandidates
+    .filter((candidate) => !oversizedTranscriptIds.has(candidate.id))
+    .map((candidate) => candidate.id)
   const transcripts =
     selectedIds.length > 0
       ? await db
@@ -244,7 +252,9 @@ export async function queryMemoryTableRows({
       : []
   const transcriptById = new Map(transcripts.map((record) => [record.id, record.data]))
   const rows = selectedCandidates.flatMap((candidate, index) => {
-    const transcript = transcriptById.get(candidate.id)
+    const transcript = oversizedTranscriptIds.has(candidate.id)
+      ? omittedTranscript
+      : transcriptById.get(candidate.id)
     if (transcript === undefined) return []
     return [
       mapMemoryRecordToTableRow(