omi/web/app/src/lib/__tests__/apiMemories.test.ts at main · ghzhost/omi · GitHub

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import { beforeEach, describe, expect, it, vi } from 'vitest';

const { getIdToken } = vi.hoisted(() => ({ getIdToken: vi.fn() }));
const { getWebDeviceIdHash } = vi.hoisted(() => ({ getWebDeviceIdHash: vi.fn() }));

vi.mock('@/lib/firebase', () => ({ getIdToken }));
vi.mock('@/lib/clientDevice', () => ({ getWebDeviceIdHash }));

import { createMemory, getMemories } from '@/lib/api';

describe('getMemories ledger boundary', () => {
  beforeEach(() => {
    getIdToken.mockResolvedValue('test-token');
    getWebDeviceIdHash.mockResolvedValue(null);
    vi.unstubAllGlobals();
  });

  it('normalizes malformed/future rows at the used API consumer without dropping text rows', async () => {
    const fetchMock = vi.fn(
      async () =>
        new Response(
          JSON.stringify([
            {
              id: 'legacy',
              uid: 'web-user-1',
              content: 'Legacy text',
              created_at: '2026-08-23T00:00:00Z',
              updated_at: '2026-08-23T00:00:00Z',
              layer: 'long_term',
            },
            {
              id: 'future',
              uid: 'web-user-1',
              content: 'Future text',
              created_at: '2026-08-23T00:00:00Z',
              updated_at: '2026-08-23T00:00:00Z',
              layer: 'long_term',
              ledger_schema_version: 'knowledge_ledger.v2',
              kind: 'fact',
              slot: 'future-slot',
              body: 'future-body',
              trigger_condition: { unsupported: true },
              intent_backed: true,
              curation_weight: 3,
              write_reason: 'direct_user_statement',
              subject_entity_id: 'user-1',
              evidence: [
                null,
                { evidence_id: 'future-evidence' },
                {
                  evidence_id: 'future-evidence',
                  independence_group: 'future-group',
                  extra: true,
                },
              ],
            },
            { id: 'bad', uid: 'web-user-1', content: '   ' },
          ]),
          { headers: { 'content-type': 'application/json' } },
        ),
    );
    vi.stubGlobal('fetch', fetchMock);

    const memories = await getMemories();

    expect(memories).toHaveLength(2);
    expect(memories.map((memory) => memory.content)).toEqual([
      'Legacy text',
      'Future text',
    ]);
    expect(memories[0]).not.toHaveProperty('kind');
    expect(memories[1]).not.toHaveProperty('kind');
    expect(memories[1].evidence).toEqual([
      { evidence_id: 'future-evidence', independence_group: 'future-group', extra: true },
    ]);
    for (const field of [
      'kind',
      'slot',
      'body',
      'trigger_condition',
      'intent_backed',
      'curation_weight',
      'write_reason',
      'subject_entity_id',
    ]) {
      expect(memories[1]).not.toHaveProperty(field);
    }
  });

  it('normalizes the actual createMemory response before returning it', async () => {
    const fetchMock = vi.fn(
      async () =>
        new Response(
          JSON.stringify({
            id: 'created',
            uid: 'web-user-1',
            content: 'Created text',
            created_at: '2026-08-23T00:00:00Z',
            updated_at: '2026-08-23T00:00:00Z',
            ledger_schema_version: 'knowledge_ledger.v1',
            kind: 'fact',
            slot: 'preferred_name',
            body: 'wrong kind',
            trigger_condition: { wrong: true },
            curation_weight: '3',
            intent_backed: 'true',
            evidence: [
              { evidence_id: 'created-evidence', independence_group: 'created-group' },
            ],
          }),
          { headers: { 'content-type': 'application/json' } },
        ),
    );
    vi.stubGlobal('fetch', fetchMock);

    const memory = await createMemory({ content: 'Created text' });

    expect(memory).toMatchObject({
      id: 'created',
      content: 'Created text',
      kind: 'fact',
      slot: 'preferred_name',
      evidence: [
        { evidence_id: 'created-evidence', independence_group: 'created-group' },
      ],
    });
    expect(memory).not.toHaveProperty('body');
    expect(memory).not.toHaveProperty('trigger_condition');
    expect(memory).not.toHaveProperty('curation_weight');
    expect(memory).not.toHaveProperty('intent_backed');
  });
});