Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
3.3 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import { buildMessageGroupChunks } from '../ChatThread'

function group(turn: number, role: 'user' | 'assistant') {
  return {
    groupKey: `${role}-${turn}`,
    items: [{ serverTurnNumber: turn }],
  }
}

function turnGroups(start: number, end: number) {
  return Array.from({ length: end - start + 1 }, (_, index) => {
    const turn = start + index
    return [group(turn, 'user'), group(turn, 'assistant')]
  }).flat()
}

describe('buildMessageGroupChunks', () => {
  it('keeps existing server-turn chunk keys stable when a new turn is appended', () => {
    const before = buildMessageGroupChunks(turnGroups(1, 8))
    const after = buildMessageGroupChunks(turnGroups(1, 9))

    expect(before.map(chunk => chunk.chunkKey)).toEqual(['server-turns-0', 'server-turns-1'])
    expect(after.map(chunk => chunk.chunkKey)).toEqual([
      'server-turns-0',
      'server-turns-1',
      'server-turns-2',
    ])
    expect(after.slice(0, before.length).map(chunk => chunk.chunkKey)).toEqual(
      before.map(chunk => chunk.chunkKey)
    )
    expect(after[0]?.groups.map(({ group }) => group.groupKey)).toEqual(
      before[0]?.groups.map(({ group }) => group.groupKey)
    )
    expect(after[1]?.groups.map(({ group }) => group.groupKey)).toEqual(
      before[1]?.groups.map(({ group }) => group.groupKey)
    )
  })

  it('keeps existing server-turn chunks stable when older turns are prepended', () => {
    const before = buildMessageGroupChunks(turnGroups(5, 12))
    const after = buildMessageGroupChunks(turnGroups(1, 12))
    const afterByKey = new Map(after.map(chunk => [chunk.chunkKey, chunk]))

    expect(before.map(chunk => chunk.chunkKey)).toEqual(['server-turns-1', 'server-turns-2'])
    for (const chunk of before) {
      expect(afterByKey.get(chunk.chunkKey)?.groups.map(({ group }) => group.groupKey)).toEqual(
        chunk.groups.map(({ group }) => group.groupKey)
      )
    }
  })

  it('suffixes repeated server buckets separated by a local-only group', () => {
    const local = { groupKey: 'local-message', items: [{}] }
    const chunks = buildMessageGroupChunks([group(1, 'user'), local, group(2, 'assistant')])

    expect(chunks.map(chunk => chunk.chunkKey)).toEqual([
      'server-turns-0',
      'local-local-message',
      'server-turns-0#assistant-2',
    ])
  })

  it('keeps repeated server bucket keys stable when an earlier segment is inserted', () => {
    const localA = { groupKey: 'local-a', items: [{}] }
    const localB = { groupKey: 'local-b', items: [{}] }
    const insertedLocal = { groupKey: 'inserted-local', items: [{}] }
    const before = buildMessageGroupChunks([
      group(1, 'user'),
      localA,
      group(2, 'assistant'),
      localB,
      group(3, 'user'),
    ])
    const after = buildMessageGroupChunks([
      group(1, 'user'),
      insertedLocal,
      group(1, 'assistant'),
      localA,
      group(2, 'assistant'),
      localB,
      group(3, 'user'),
    ])
    const keyFor = (chunks: ReturnType<typeof buildMessageGroupChunks>, groupKey: string) =>
      chunks.find(chunk => chunk.groups.some(entry => entry.group.groupKey === groupKey))?.chunkKey

    expect(keyFor(after, 'assistant-2')).toBe(keyFor(before, 'assistant-2'))
    expect(keyFor(after, 'user-3')).toBe(keyFor(before, 'user-3'))
  })
})