Files
TREK/shared/src/assistant/assistant.schema.spec.ts
T
Maurice 72c61f242e fix(assistant): book changes undo per page, and the Studio prompt fits the user's rights
Changes held in one step are applied in the order the chat shows them, so
"undo all" walks them back newest first. A page put back is checked against
the digest of the page as the change left it, so a save to another page no
longer blocks the undo; restore_book_page takes these digests as an option and
keeps the whole book check without them. The book card counts the user's own
photos, the preview tool describes itself per role, a copy into another trip
names no places, a held vacay toggle says up front whether it can be taken
back, and a viewer's Studio prompt names none of the design's tools.
2026-10-23 01:45:16 +00:00

445 lines
19 KiB
TypeScript

/// <reference types="node" />
import {
ASSISTANT_CHANGE_LABEL_KEYS,
assistantAddFoundPlaceRequestSchema,
assistantAddFoundPlaceResponseSchema,
assistantAttachmentRequestSchema,
assistantChangePreviewSchema,
assistantChangePreviewWriteSchema,
assistantChatRequestSchema,
assistantDecisionsRequestSchema,
assistantFoundPlaceSchema,
assistantMessageSchema,
assistantPlacesSchema,
assistantStopRequestSchema,
assistantWeatherSchema,
UI_STREAM_DONE,
uiStreamChunkSchema,
type UiStreamChunk,
} from './assistant.schema';
import { readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { describe, expect, it } from 'vitest';
const ctx = { locale: 'de', timeZone: 'Europe/Berlin' };
/** The `data:` payloads of an SSE body, in order. */
const dataEvents = (body: string) =>
body
.split('\n\n')
.filter((event) => event.startsWith('data: '))
.map((event) => event.slice('data: '.length));
const fixture = readFileSync(fileURLToPath(new URL('./__fixtures__/ui-stream.v1.txt', import.meta.url)), 'utf8');
describe('assistantChatRequestSchema', () => {
it('takes a first message without a thread and trims the text', () => {
const parsed = assistantChatRequestSchema.parse({ ...ctx, threadId: null, text: ' Plan day 2 ' });
expect(parsed.text).toBe('Plan day 2');
});
it('refuses blank or overlong text, a bad thread id and unknown keys', () => {
expect(assistantChatRequestSchema.safeParse({ ...ctx, threadId: null, text: ' ' }).success).toBe(false);
expect(assistantChatRequestSchema.safeParse({ ...ctx, threadId: null, text: 'x'.repeat(32_001) }).success).toBe(
false,
);
expect(assistantChatRequestSchema.safeParse({ ...ctx, threadId: 0, text: 'hi' }).success).toBe(false);
expect(assistantChatRequestSchema.safeParse({ ...ctx, threadId: null, text: 'hi', tripId: 9 }).success).toBe(false);
});
it('carries a focus of at most 20 places', () => {
const many = Array.from({ length: 21 }, (_, i) => i + 1);
expect(
assistantChatRequestSchema.safeParse({ ...ctx, threadId: 3, text: 'hi', focus: { dayId: 4, placeIds: [1] } })
.success,
).toBe(true);
expect(
assistantChatRequestSchema.safeParse({ ...ctx, threadId: 3, text: 'hi', focus: { placeIds: many } }).success,
).toBe(false);
});
it('needs the locale and time zone', () => {
expect(assistantChatRequestSchema.safeParse({ threadId: null, text: 'hi' }).success).toBe(false);
});
});
describe('assistantAttachmentRequestSchema', () => {
it('reads the multipart text fields, the thread id from its text', () => {
expect(assistantAttachmentRequestSchema.parse({ ...ctx })).toEqual(ctx);
expect(assistantAttachmentRequestSchema.parse({ ...ctx, threadId: '12' })).toEqual({ ...ctx, threadId: 12 });
});
it('refuses a bad thread id, unknown fields and a missing context', () => {
for (const threadId of ['0', '-1', 'abc', '1.5']) {
expect(assistantAttachmentRequestSchema.safeParse({ ...ctx, threadId }).success, threadId).toBe(false);
}
expect(assistantAttachmentRequestSchema.safeParse({ ...ctx, text: 'hi' }).success).toBe(false);
expect(assistantAttachmentRequestSchema.safeParse({ threadId: '3' }).success).toBe(false);
});
});
describe('assistantDecisionsRequestSchema', () => {
it('takes one to twelve decisions', () => {
const decision = { toolCallId: 'a', approved: true };
expect(assistantDecisionsRequestSchema.safeParse({ ...ctx, decisions: [decision] }).success).toBe(true);
expect(assistantDecisionsRequestSchema.safeParse({ ...ctx, decisions: [] }).success).toBe(false);
expect(
assistantDecisionsRequestSchema.safeParse({ ...ctx, decisions: Array.from({ length: 51 }, () => decision) })
.success,
).toBe(false);
});
it('never takes arguments for a call, only the decision', () => {
expect(
assistantDecisionsRequestSchema.safeParse({
...ctx,
decisions: [{ toolCallId: 'a', approved: true, args: { name: 'x' } }],
}).success,
).toBe(false);
});
});
describe('assistantStopRequestSchema', () => {
it('is an empty JSON object', () => {
expect(assistantStopRequestSchema.safeParse({}).success).toBe(true);
expect(assistantStopRequestSchema.safeParse({ force: true }).success).toBe(false);
});
});
describe('assistantChangePreviewSchema', () => {
const preview = {
toolCallId: 'c1',
verbKey: 'addPlace',
subject: 'Kinkaku-ji',
rows: [{ op: 'add', labelKey: 'address', before: null, after: 'Kyoto' }],
dayId: null,
placeIds: [],
undoable: true,
};
it('labels rows from the closed key list only', () => {
expect(assistantChangePreviewSchema.safeParse(preview).success).toBe(true);
expect(
assistantChangePreviewSchema.safeParse({ ...preview, rows: [{ ...preview.rows[0], labelKey: 'evil' }] }).success,
).toBe(false);
expect(assistantChangePreviewWriteSchema.safeParse({ ...preview, verbKey: 'deleteTrip' }).success).toBe(false);
});
it('reads a verb a later build added as a plain update, and writes none it does not know', () => {
expect(assistantChangePreviewSchema.parse({ ...preview, verbKey: 'laterVerb' }).verbKey).toBe('genericUpdate');
expect(assistantChangePreviewWriteSchema.parse(preview).verbKey).toBe('addPlace');
expect(assistantChangePreviewWriteSchema.safeParse({ ...preview, card: { kind: 'nope' } }).success).toBe(false);
});
it('names the proposal a taken change came from by its call id, bounded like the take request', () => {
expect(assistantChangePreviewWriteSchema.parse({ ...preview, takenFrom: 'call_hike' }).takenFrom).toBe('call_hike');
expect(assistantChangePreviewSchema.parse(preview).takenFrom).toBeUndefined();
expect(assistantChangePreviewWriteSchema.safeParse({ ...preview, takenFrom: '' }).success).toBe(false);
expect(assistantChangePreviewWriteSchema.safeParse({ ...preview, takenFrom: 'c'.repeat(65) }).success).toBe(false);
});
it('holds at most twelve rows', () => {
const rows = ASSISTANT_CHANGE_LABEL_KEYS.slice(0, 13).map((labelKey) => ({
op: 'add',
labelKey,
before: null,
after: 'x',
}));
expect(assistantChangePreviewSchema.safeParse({ ...preview, rows }).success).toBe(false);
});
});
describe('assistantMessageSchema', () => {
it('reads a stored message with an expired approval', () => {
const parsed = assistantMessageSchema.safeParse({
id: '12',
role: 'assistant',
status: 'awaiting_approval',
createdAt: '2026-10-21T08:00:00.000Z',
parts: [
{ type: 'text', text: 'Adding it.' },
{
type: 'tool-call',
toolCallId: 'c1',
toolName: 'create_place',
args: { name: 'Kinkaku-ji' },
approval: { id: 'c1', resolution: 'expired' },
},
],
});
expect(parsed.success).toBe(true);
});
it('reads a user message that attached a file, by its name, type and size only', () => {
const message = { id: '13', role: 'user', status: 'complete', createdAt: '2026-10-21T08:00:00.000Z' };
const attachment = { type: 'attachment', name: 'ticket.pdf', mime: 'application/pdf', size: 2048 };
expect(assistantMessageSchema.safeParse({ ...message, parts: [attachment] }).success).toBe(true);
const negative = { ...attachment, size: -1 };
expect(assistantMessageSchema.safeParse({ ...message, parts: [negative] }).success).toBe(false);
});
});
describe('uiStreamChunkSchema', () => {
it('reads an unknown error code as generic', () => {
expect(uiStreamChunkSchema.parse({ type: 'error', errorText: 'something_new' })).toEqual({
type: 'error',
errorText: 'generic',
});
expect(uiStreamChunkSchema.parse({ type: 'error', errorText: 'daily_limit' })).toEqual({
type: 'error',
errorText: 'daily_limit',
});
});
it('refuses a chunk type it does not know', () => {
expect(uiStreamChunkSchema.safeParse({ type: 'reasoning-delta', id: 'r', delta: 'x' }).success).toBe(false);
});
});
describe('ui-stream.v1 fixture', () => {
const events = dataEvents(fixture);
const chunks = events.slice(0, -1).map((event) => uiStreamChunkSchema.parse(JSON.parse(event)));
const ofType = <T extends UiStreamChunk['type']>(type: T) =>
chunks.filter((c): c is Extract<UiStreamChunk, { type: T }> => c.type === type);
it('is a stream of valid chunks closed by [DONE]', () => {
expect(events.at(-1)).toBe(UI_STREAM_DONE);
expect(chunks[0]?.type).toBe('start');
expect(chunks.at(-1)).toEqual({ type: 'finish', finishReason: 'tool-calls' });
});
it('names the new thread before anything else is said', () => {
expect(chunks[1]?.type).toBe('data-trek-thread');
});
it('asks for approval with the call id and previews that same call', () => {
const [request] = ofType('tool-approval-request');
const [change] = ofType('data-trek-change');
expect(request).toBeDefined();
expect(request?.approvalId).toBe(request?.toolCallId);
expect(change?.data.toolCallId).toBe(request?.toolCallId);
expect(ofType('tool-input-available').map((c) => c.toolCallId)).toContain(request?.toolCallId);
});
it('closes every text block it opens', () => {
const opened = ofType('text-start').map((c) => c.id);
expect(opened.length).toBeGreaterThan(0);
expect(ofType('text-end').map((c) => c.id)).toEqual(opened);
});
});
describe('mentions in a chat request', () => {
const base = { ...ctx, threadId: 3, text: 'Move @Louvre to @Friday' };
it('names up to ten days, places or bookings by id, never by label', () => {
const mentions = [
{ kind: 'place', id: 4 },
{ kind: 'day', id: 9 },
{ kind: 'reservation', id: 2 },
];
expect(assistantChatRequestSchema.safeParse({ ...base, mentions }).success).toBe(true);
const tooMany = Array.from({ length: 51 }, () => ({ kind: 'place', id: 4 }));
expect(assistantChatRequestSchema.safeParse({ ...base, mentions: tooMany }).success).toBe(false);
const labelled = [{ kind: 'place', id: 4, label: 'Louvre' }];
expect(assistantChatRequestSchema.safeParse({ ...base, mentions: labelled }).success).toBe(false);
expect(assistantChatRequestSchema.safeParse({ ...base, mentions: [{ kind: 'trip', id: 4 }] }).success).toBe(false);
});
});
describe('assistantAddFoundPlaceRequestSchema', () => {
const parse = (body: Record<string, unknown>) => assistantAddFoundPlaceRequestSchema.safeParse({ ...ctx, ...body });
it('names a found place by its ref and the day it goes on', () => {
expect(parse({ ref: 'toolu_01:2', dayId: 32 }).success).toBe(true);
});
it('refuses an empty or overlong ref, a bad day and anything about the place itself', () => {
expect(parse({ ref: '', dayId: 32 }).success).toBe(false);
expect(parse({ ref: 'x'.repeat(81), dayId: 32 }).success).toBe(false);
expect(parse({ ref: 'a:1', dayId: 0 }).success).toBe(false);
expect(parse({ ref: 'a:1', dayId: 3, name: 'Elsewhere' }).success).toBe(false);
expect(assistantAddFoundPlaceRequestSchema.safeParse({ ref: 'a:1', dayId: 3 }).success).toBe(false);
});
});
describe('the effect of a change', () => {
const preview = {
toolCallId: 'c1',
verbKey: 'addPlaceToDay',
subject: 'Kinkaku-ji',
rows: [],
dayId: 32,
placeIds: [],
undoable: true,
};
const ghost = { name: 'Kinkaku-ji', lat: 35.0394, lng: 135.7292, categoryId: null };
const add = { kind: 'add', dayId: 32, fromDayId: null, placeId: null, assignmentId: null, place: ghost };
const withEffect = (effect: unknown) => assistantChangePreviewSchema.safeParse({ ...preview, effect }).success;
it('is optional, so previews stored before it still read', () => {
expect(assistantChangePreviewSchema.safeParse(preview).success).toBe(true);
expect(withEffect(null)).toBe(true);
});
it('places a new place on its day, or moves an existing one between days', () => {
expect(withEffect(add)).toBe(true);
const existing = { placeId: 7, assignmentId: 12, place: null };
expect(withEffect({ kind: 'move', dayId: 32, fromDayId: 31, ...existing })).toBe(true);
expect(withEffect({ kind: 'remove', dayId: 31, fromDayId: null, ...existing })).toBe(true);
});
it('refuses a position off the globe, an overlong name and an unknown kind', () => {
expect(withEffect({ ...add, place: { ...ghost, lat: 91 } })).toBe(false);
expect(withEffect({ ...add, place: { ...ghost, lng: -181 } })).toBe(false);
expect(withEffect({ ...add, place: { ...ghost, name: 'x'.repeat(201) } })).toBe(false);
expect(withEffect({ ...add, kind: 'swap' })).toBe(false);
});
});
describe('assistantFoundPlaceSchema', () => {
const place = {
ref: 'toolu_01:0',
name: 'Trattoria da Enzo',
address: 'Via dei Vascellari 29, Roma',
lat: 41.8885,
lng: 12.4771,
kind: 'food',
rating: 4.6,
openNow: null,
googlePlaceId: 'ChIJ-abc_123',
osmId: null,
photoKey: 'ChIJ-abc_123',
inTripPlaceId: null,
};
const withPlace = (patch: Record<string, unknown>) => assistantFoundPlaceSchema.safeParse({ ...place, ...patch });
it('reads a place with a source id as its photo key, or coordinates', () => {
expect(withPlace({}).success).toBe(true);
expect(withPlace({ photoKey: 'coords:41.8885,12.4771' }).success).toBe(true);
expect(withPlace({ photoKey: 'coords:-33.9,-70.6' }).success).toBe(true);
expect(withPlace({ photoKey: null }).success).toBe(true);
});
it('never takes a URL or anything with a path as the photo key', () => {
const notKeys = [
'https://evil.example/p.jpg',
'//evil.example/p.jpg',
'/api/maps/place-photo/x/bytes',
'a/b',
'coords:1,2;x',
'',
];
for (const photoKey of notKeys) expect(withPlace({ photoKey }).success, photoKey).toBe(false);
});
it('refuses a Google id that is not one, a rating past five and an unknown kind', () => {
expect(withPlace({ googlePlaceId: 'a b' }).success).toBe(false);
expect(withPlace({ rating: 5.1 }).success).toBe(false);
expect(withPlace({ kind: 'casino' }).success).toBe(false);
});
it('holds at most twenty places to a step and counts the rest', () => {
const places = Array.from({ length: 21 }, (_, i) => ({ ...place, ref: `toolu_01:${i}` }));
const step = (body: Record<string, unknown>) =>
assistantPlacesSchema.safeParse({ toolCallId: 'toolu_01', ...body });
expect(step({ places: places.slice(0, 20), more: 1 }).success).toBe(true);
expect(step({ places, more: 0 }).success).toBe(false);
expect(step({ places: [], more: -1 }).success).toBe(false);
});
});
describe('assistantWeatherSchema', () => {
const day = {
dayId: 32,
date: '2026-06-12',
main: 'Clear',
tempMax: 24.5,
tempMin: 16,
rainPct: 10,
kind: 'forecast',
};
it('reads one to sixteen days, a climate day without a low or a rain chance', () => {
expect(assistantWeatherSchema.safeParse({ days: [day] }).success).toBe(true);
const climate = { ...day, dayId: null, tempMin: null, rainPct: null, kind: 'climate' };
expect(assistantWeatherSchema.safeParse({ days: [climate] }).success).toBe(true);
expect(assistantWeatherSchema.safeParse({ days: [] }).success).toBe(false);
expect(assistantWeatherSchema.safeParse({ days: Array.from({ length: 17 }, () => day) }).success).toBe(false);
});
it('refuses a date that is not a calendar date and a rain chance past 100', () => {
expect(assistantWeatherSchema.safeParse({ days: [{ ...day, date: '12.06.2026' }] }).success).toBe(false);
expect(assistantWeatherSchema.safeParse({ days: [{ ...day, rainPct: 101 }] }).success).toBe(false);
});
});
describe('the new message parts', () => {
const message = { id: '14', status: 'complete', createdAt: '2026-10-21T08:00:00.000Z' };
const rainyDay = { dayId: 32, date: '2026-06-12', main: 'Rain', tempMax: 18, tempMin: 12, rainPct: 80 };
it('keeps found places and the weather on an answer', () => {
const parts = [
{ type: 'data-trek-places', data: { toolCallId: 'toolu_01', places: [], more: 0 } },
{ type: 'data-trek-weather', data: { days: [{ ...rainyDay, kind: 'forecast' }] } },
];
expect(assistantMessageSchema.safeParse({ ...message, role: 'assistant', parts }).success).toBe(true);
});
it('keeps the checked mentions of a question with their labels', () => {
const item = { kind: 'place', id: 4, label: 'Louvre' };
const parts = [
{ type: 'text', text: 'Is @Louvre open on Monday?' },
{ type: 'data-trek-mentions', data: { items: [item] } },
];
expect(assistantMessageSchema.safeParse({ ...message, role: 'user', parts }).success).toBe(true);
const tooLong = [{ type: 'data-trek-mentions', data: { items: [{ ...item, label: 'x'.repeat(121) }] } }];
expect(assistantMessageSchema.safeParse({ ...message, role: 'user', parts: tooLong }).success).toBe(false);
});
it('never stores the live activity of a step', () => {
const activity = { type: 'data-trek-activity', data: { toolCallId: 'toolu_01', label: null, area: null } };
expect(assistantMessageSchema.safeParse({ ...message, role: 'assistant', parts: [activity] }).success).toBe(false);
});
it('answers a suggested found place with the message that holds it', () => {
const answer = { ...message, role: 'assistant', status: 'awaiting_approval', parts: [] };
expect(assistantAddFoundPlaceResponseSchema.safeParse({ message: answer }).success).toBe(true);
expect(assistantAddFoundPlaceResponseSchema.safeParse({}).success).toBe(false);
});
});
describe('the new stream chunks', () => {
const activity = (data: Record<string, unknown>) =>
uiStreamChunkSchema.safeParse({ type: 'data-trek-activity', data: { toolCallId: 'toolu_01', ...data } }).success;
it('streams the live activity of a step, marked transient, with a point or a box', () => {
const point = { type: 'point', lat: 41.89, lng: 12.47, radiusM: 1500 };
const bbox = { type: 'bbox', south: 41.8, west: 12.4, north: 41.95, east: 12.6 };
for (const area of [point, bbox, null]) expect(activity({ label: 'Trastevere', area })).toBe(true);
const chunk = { type: 'data-trek-activity', transient: true, data: { toolCallId: 't', label: null, area: null } };
expect(uiStreamChunkSchema.safeParse(chunk).success).toBe(true);
});
it('refuses an activity with a radius past 50 km or a label past 80 characters', () => {
const area = { type: 'point', lat: 41.89, lng: 12.47, radiusM: 50_001 };
expect(activity({ label: null, area })).toBe(false);
expect(activity({ label: 'x'.repeat(81), area: null })).toBe(false);
});
it('streams found places and the weather as they are stored', () => {
const places = { type: 'data-trek-places', data: { toolCallId: 'toolu_01', places: [], more: 3 } };
const day = { dayId: null, date: '2026-06-12', main: 'Clouds', tempMax: 21, tempMin: null, rainPct: null };
const weather = { type: 'data-trek-weather', data: { days: [{ ...day, kind: 'current' }] } };
expect(uiStreamChunkSchema.safeParse(places).success).toBe(true);
expect(uiStreamChunkSchema.safeParse(weather).success).toBe(true);
});
it('names the found-place refusal by its code', () => {
expect(uiStreamChunkSchema.parse({ type: 'error', errorText: 'decide_first' })).toEqual({
type: 'error',
errorText: 'decide_first',
});
});
});