fix(memory): admit only complete stored tool exchanges

Author: icecrasher321

apps/sim/executor/handlers/agent/memory.durability.test.ts

@@ -208,6 +208,42 @@ describe('optional Agent memory durability failures', () => {
     }
   )
 
+  it.each(['missing', 'mismatched', 'intervening', 'duplicate', 'orphan'])(
+    'omits a %s legacy result group before provider conversion',
+    async (failure) => {
+      const call = {
+        role: 'assistant',
+        content: null,
+        function_call: { name: 'lookup', arguments: '{}' },
+      }
+      const result = { role: 'function', name: 'lookup', content: 'Saved result' }
+      const messages =
+        failure === 'missing'
+          ? [call]
+          : failure === 'mismatched'
+            ? [call, { ...result, name: 'different' }]
+            : failure === 'intervening'
+              ? [call, { role: 'user', content: 'interruption' }, result]
+              : failure === 'duplicate'
+                ? [call, result, result]
+                : [result]
+      mocks.items.mockResolvedValue({
+        items: [
+          {
+            kind: 'exchange',
+            appendKey: 'step:1',
+            turnId: 'previous-turn',
+            data: { version: 1, messages },
+            provenance: { status: 'exact', entries: [] },
+          },
+        ],
+      })
+      await expect(
+        new Memory().fetchMemoryMessages(ctx, inputs, undefined, { richHistory: true })
+      ).resolves.toEqual(prefix)
+    }
+  )
+
   it('drops optional scoped appends when storage fails without retrying an unscoped write', async () => {
     mocks.append.mockRejectedValue(storageFailure())
     await expect(

apps/sim/executor/handlers/agent/memory.ts

@@ -29,6 +29,7 @@ import {
   readPlainMemoryTail,
   seedMemoryMessages,
 } from '@/lib/memory/conversation-store'
+import { parseConversationHistoryGroup } from '@/lib/memory/history-group'
 import {
   markConversationExchangeGroup,
   selectConversationContextWindow,
@@ -744,21 +745,8 @@ export class Memory {
           encryptedNative =
             typeof item.data.encryptedNative === 'string' ? item.data.encryptedNative : undefined
         }
-        const valid = values.every(
-          (value) =>
-            isPlainRecord(value) &&
-            ['system', 'user', 'assistant', 'tool', 'function'].includes(String(value.role)) &&
-            (typeof value.content === 'string' ||
-              (value.role === 'assistant' &&
-                value.content === null &&
-                (Array.isArray(value.tool_calls) ||
-                  (isPlainRecord(value.function_call) &&
-                    typeof value.function_call.name === 'string' &&
-                    value.function_call.name.length > 0 &&
-                    typeof value.function_call.arguments === 'string'))))
-        )
-        if (!valid || values.length === 0) continue
-        const group = values as Message[]
+        const group = parseConversationHistoryGroup(values)
+        if (!group) continue
         const groupBytes =
           Buffer.byteLength(JSON.stringify(item.data), 'utf8') +
           Buffer.byteLength(JSON.stringify(item.provenance), 'utf8')

apps/sim/lib/memory/history-group.test.ts

@@ -0,0 +1,64 @@
+/** @vitest-environment node */
+import { describe, expect, it } from 'vitest'
+import { parseConversationHistoryGroup } from '@/lib/memory/history-group'
+
+const legacyCall = {
+  role: 'assistant',
+  content: null,
+  function_call: { name: 'lookup', arguments: '{}' },
+}
+const legacyResult = { role: 'function', name: 'lookup', content: 'result' }
+const toolCall = (id: string) => ({
+  id,
+  type: 'function',
+  function: { name: 'lookup', arguments: '{}' },
+})
+const parallelCall = {
+  role: 'assistant',
+  content: null,
+  tool_calls: [toolCall('first'), toolCall('second')],
+}
+const result = (id: string) => ({ role: 'tool', tool_call_id: id, content: 'result' })
+const text = { role: 'user', content: 'conversation text or bounded execution record' }
+
+describe('stored conversation history groups', () => {
+  it.each([
+    [text],
+    [legacyCall, legacyResult],
+    [{ ...legacyCall, content: 'Calling lookup' }, legacyResult],
+    [legacyCall, legacyResult, legacyCall, legacyResult],
+    [parallelCall, result('second'), result('first')],
+    [parallelCall, result('first'), { ...result('second'), content: '{"error":"tool failed"}' }],
+  ])('retains complete history unchanged: %j', (...group) => {
+    expect(parseConversationHistoryGroup(group)).toBe(group)
+  })
+
+  it.each([
+    [],
+    [{ role: { toString: 1 }, content: 'invalid role' }],
+    [legacyCall],
+    [{ ...legacyCall, content: 'Calling lookup' }],
+    [legacyResult],
+    [legacyCall, { ...legacyResult, name: 'different' }],
+    [legacyCall, legacyResult, legacyResult],
+    [legacyCall, text, legacyResult],
+    [legacyCall, result('lookup')],
+    [parallelCall],
+    [parallelCall, result('first')],
+    [parallelCall, result('first'), result('first')],
+    [parallelCall, result('first'), result('different')],
+    [parallelCall, result('first'), text, result('second')],
+    [result('first'), parallelCall, result('first'), result('second')],
+    [{ ...parallelCall, tool_calls: [toolCall('first'), toolCall('first')] }, result('first')],
+    [{ ...parallelCall, tool_calls: [{ ...toolCall('first'), id: '' }] }, result('')],
+    [{ ...parallelCall, function_call: legacyCall.function_call }, legacyResult],
+    [{ ...legacyCall, role: 'user' }, legacyResult],
+    [{ ...parallelCall, role: 'user' }, result('first'), result('second')],
+    [{ role: 'assistant', content: null }],
+    [{ role: 'assistant', content: null, tool_calls: [] }],
+    [{ role: 'assistant', content: 'text', tool_calls: 'invalid' }],
+    [{ ...legacyCall, function_call: { name: 'lookup', arguments: {} } }, legacyResult],
+  ])('omits incomplete or malformed groups: %j', (...group) => {
+    expect(parseConversationHistoryGroup(group)).toBeUndefined()
+  })
+})

apps/sim/lib/memory/history-group.ts

@@ -0,0 +1,67 @@
+import { isPlainRecord } from '@sim/utils/object'
+import type { Message } from '@/providers/types'
+
+/** Stored history is admitted as a whole group, with adjacent, fully resolved call batches. */
+export function parseConversationHistoryGroup(
+  values: readonly unknown[]
+): readonly Message[] | undefined {
+  if (values.length === 0) return undefined
+  const pending = new Set<string>()
+  for (const value of values) {
+    if (
+      !isPlainRecord(value) ||
+      typeof value.role !== 'string' ||
+      !['system', 'user', 'assistant', 'tool', 'function'].includes(value.role)
+    )
+      return undefined
+
+    const calls: string[] = []
+    if (value.function_call != null) {
+      const call = value.function_call
+      if (
+        !isPlainRecord(call) ||
+        typeof call.name !== 'string' ||
+        !call.name ||
+        typeof call.arguments !== 'string'
+      )
+        return undefined
+      calls.push(`function:${call.name}`)
+    }
+    if (value.tool_calls != null) {
+      if (!Array.isArray(value.tool_calls) || (calls.length > 0 && value.tool_calls.length > 0))
+        return undefined
+      for (const call of value.tool_calls) {
+        if (
+          !isPlainRecord(call) ||
+          typeof call.id !== 'string' ||
+          !call.id ||
+          call.type !== 'function' ||
+          !isPlainRecord(call.function) ||
+          typeof call.function.name !== 'string' ||
+          !call.function.name ||
+          typeof call.function.arguments !== 'string'
+        )
+          return undefined
+        calls.push(`tool:${call.id}`)
+      }
+    }
+    if (
+      (calls.length > 0 && value.role !== 'assistant') ||
+      (typeof value.content !== 'string' &&
+        !(value.role === 'assistant' && value.content === null && calls.length > 0))
+    )
+      return undefined
+
+    if (value.role === 'function' || value.role === 'tool') {
+      const id = value.role === 'function' ? value.name : value.tool_call_id
+      if (typeof id !== 'string' || !pending.delete(`${value.role}:${id}`)) return undefined
+    } else {
+      if (pending.size > 0) return undefined
+      for (const call of calls) {
+        if (pending.has(call)) return undefined
+        pending.add(call)
+      }
+    }
+  }
+  return pending.size === 0 ? (values as readonly Message[]) : undefined
+}