/** * "Plan this" on a proposed hike or city walk, over the real thread, message * and tool call repositories on a migrated test db: the proposal comes from * the call and card stored in the thread, never from the request, and the * change that creates it is held as a card in one transaction, refused while * a turn runs, while another change waits within its day, for a proposal the thread does not * hold and for one nothing can be created from. A walk is asked again, since * the stored answer is the model's shortened copy. * * Replaced: the trip tools (what the trip reads as), the rate limit, the * stream registry and the airports. */ import { AssistantMessages } from '../../../../src/db/entities/AssistantMessages.entity'; import { AssistantThreads } from '../../../../src/db/entities/AssistantThreads.entity'; import { AssistantToolCalls } from '../../../../src/db/entities/AssistantToolCalls.entity'; import { dbNow } from '../../../../src/db/types'; import { AirportsService } from '../../../../src/nest/airports/airports.service'; import { AssistantProposalsService, pendingCardOf, storedProposal, takeArgsOf, } from '../../../../src/nest/assistant/assistant-proposals.service'; import { AssistantStreamRegistry } from '../../../../src/nest/assistant/assistant-stream.registry'; import { AssistantToolsService } from '../../../../src/nest/assistant/assistant-tools.service'; import { AssistantCardContext } from '../../../../src/nest/assistant/cards/card-context'; import { RateLimitService } from '../../../../src/nest/common/rate-limit.service'; import { UnitOfWork } from '../../../../src/nest/database/unit-of-work'; import { tourRouteCard } from '../../../helpers/assistant-tour-cards'; import { createSnapshotTestDb } from '../../../helpers/db-mock'; import { createRow, findRows, updateRows } from '../../../helpers/factories/rows'; import { makeTrip } from '../../../helpers/factories/trips'; import { makeUser } from '../../../helpers/factories/users'; import { resetTestDb } from '../../../helpers/test-db'; import { createTestModule, type TestModule } from '../../../helpers/test-module'; import { MikroORM } from '@mikro-orm/core'; import { MikroOrmModule } from '@mikro-orm/nestjs'; import type { TourRouteCard } from '@trek/shared'; import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'; const db = createSnapshotTestDb(); let t: TestModule; const WALK_RESULT = { date: '2026-06-12', frame: { start_time: '10:00', end_time: '14:00' }, can_create: true, stations: [ { lat: 48.137, lng: 11.575, name: 'Marienplatz', arrival: '10:00', stay_minutes: 0 }, { lat: 48.14, lng: 11.58, name: 'Museum', arrival: '10:10', walk_from_previous: { metres: 600, minutes: 10 } }, { lat: 48.143, lng: 11.58, name: 'Hofgarten', arrival: '11:15', walk_from_previous: { metres: 350, minutes: 5 } }, ], totals: { walk_m: 950, total_minutes: 75, ends_at: '11:15' }, stations_for_create: [ { lat: 48.137, lng: 11.575, name: 'Marienplatz', stay_minutes: 0 }, { lat: 48.14, lng: 11.58, name: 'Museum', stay_minutes: 60 }, { lat: 48.143, lng: 11.58, name: 'Hofgarten', stay_minutes: null }, ], }; /** The walk as the thread stores it: the model's copy, masked and with its lists cut to fit. */ const WALK_STORED = { ...WALK_RESULT, stations_for_create: [{ lat: 48.137, lng: 11.575, name: '[hidden]', stay_minutes: 0 }], truncated: true, }; const WALK_ARGS = { date: '2026-06-12', day_id: 32, start_time: '10:00' }; /** What the trip tools answer: one day, no places, one category; and the walk asked again. */ const reads: Record = { get_trip_summary: { trip: { title: 'Bavaria' }, days: [{ id: 32, day_number: 2, date: '2026-06-12' }] }, list_places: { places: [] }, list_categories: { categories: [{ id: 4, name: 'Sights', icon: 'Landmark' }] }, propose_city_walk: WALK_RESULT, }; const answers = async (name: string, _args?: Record) => ({ ok: true, value: reads[name] }); const session = { read: vi.fn(answers), close: vi.fn(async () => undefined), }; const tools = { open: vi.fn(async () => session) }; const rateLimit = { check: vi.fn(async () => true) }; const streams = { claim: vi.fn(async () => true), release: vi.fn(async () => undefined) }; beforeAll(async () => { t = await createTestModule({ db, imports: [MikroOrmModule.forFeature([AssistantThreads, AssistantMessages, AssistantToolCalls])], providers: [ AssistantProposalsService, AssistantCardContext, { provide: AirportsService, useValue: { findByIata: () => null } }, { provide: AssistantToolsService, useValue: tools }, { provide: RateLimitService, useValue: rateLimit }, { provide: AssistantStreamRegistry, useValue: streams }, ], }); }); beforeEach(() => { resetTestDb(db); vi.clearAllMocks(); }); afterAll(async () => { await t.close(); db.close(); }); const HIKE_ARGS = { name: 'Herzogstand', waypoints: [ { lat: 47.6, lng: 11.3, name: 'Car park' }, { lat: 47.61, lng: 11.3, name: 'Summit', poi_category: 'peak' }, ], max_hiking_difficulty: 3, variant_label: 'the short one', along: false, day_id: 32, start_time: '08:00', }; /** A thread whose answer proposed a hike (`h1`) and a city walk (`w1`), each with its card, and searched (`s1`). */ async function conversation(hikeCard: TourRouteCard = tourRouteCard()) { const orm = t.get(MikroORM); const { user } = await makeUser(orm); const trip = await makeTrip(orm, user.id); const thread = await createRow(orm, AssistantThreads, { user: user.id, trip: trip.id, title: 'Hikes' }); const walkCard = tourRouteCard({ activity: 'walk', name: null, minutesBasis: 'stations' }); const parts = JSON.stringify([ { type: 'tool-call', toolCallId: 'h1', toolName: 'propose_hike', args: HIKE_ARGS, result: { name: 'Herzogstand' } }, { type: 'data-trek-card', data: { toolCallId: 'h1', card: hikeCard } }, { type: 'tool-call', toolCallId: 'w1', toolName: 'propose_city_walk', args: WALK_ARGS, result: WALK_STORED }, { type: 'data-trek-card', data: { toolCallId: 'w1', card: walkCard } }, { type: 'tool-call', toolCallId: 's1', toolName: 'search_place', args: { query: 'huts' }, result: {} }, ]); await createRow(orm, AssistantMessages, { thread: thread.id, role: 'assistant', parts, status: 'complete' }); return { userId: user.id, tripId: trip.id, threadId: thread.id }; } function take(c: { userId: number; tripId: number; threadId: number }, toolCallId: string, threadId = c.threadId) { return t .get(AssistantProposalsService) .take(c.userId, c.tripId, threadId, { toolCallId, locale: 'en', timeZone: 'UTC' }); } function calls(threadId: number) { return findRows(t.get(MikroORM), AssistantToolCalls, { thread_id: threadId }); } describe('AssistantProposalsService', () => { it('ASTPROP-001: a proposed hike is held as create_hike with its own arguments and the card the answer showed', async () => { const c = await conversation(); const transactional = vi.spyOn(t.get(UnitOfWork), 'transactional'); const { message } = await take(c, 'h1'); expect(transactional).toHaveBeenCalledOnce(); const [call] = await calls(c.threadId); expect(call).toMatchObject({ tool_name: 'take_proposal', state: 'approval_requested' }); expect(JSON.parse(call?.args ?? '{}')).toEqual({ via: 'create_hike', name: 'Herzogstand', waypoints: HIKE_ARGS.waypoints, max_hiking_difficulty: 3, day_id: 32, start_time: '08:00', }); const preview = JSON.parse(call?.preview ?? '{}') as Record; // It names the proposal it was taken from, so the chat tells which card was taken. expect(preview).toMatchObject({ verbKey: 'addTour', subject: 'Herzogstand', dayId: 32, undoable: true, takenFrom: 'h1', }); // The card the answer showed, waiting, under the name the change saves. expect(preview.card).toEqual({ ...tourRouteCard(), source: 'pending', name: 'Herzogstand' }); expect(message.parts).toContainEqual( expect.objectContaining({ type: 'tool-call', toolCallId: call?.id, toolName: 'take_proposal' }), ); expect(streams.release).toHaveBeenCalledOnce(); expect(session.close).toHaveBeenCalledOnce(); }); it('ASTPROP-002: a proposed city walk is held as create_city_walk with the stations it answered, named by its ends', async () => { const c = await conversation(); await take(c, 'w1'); expect(session.read).toHaveBeenCalledWith('propose_city_walk', WALK_ARGS); const [call] = await calls(c.threadId); expect(JSON.parse(call?.args ?? '{}')).toEqual({ via: 'create_city_walk', name: 'Marienplatz → Hofgarten', stations: WALK_RESULT.stations_for_create, }); const preview = JSON.parse(call?.preview ?? '{}') as Record; expect(preview).toMatchObject({ verbKey: 'addTour', subject: 'Marienplatz → Hofgarten', takenFrom: 'w1' }); }); it('ASTPROP-003: a call the thread does not hold, or one that proposed nothing, is not found', async () => { const c = await conversation(); const notFound = { status: 404, code: 'not_found' }; await expect(take(c, 'nope')).rejects.toMatchObject(notFound); await expect(take(c, 's1')).rejects.toMatchObject(notFound); await expect(take(c, 'h1', c.threadId + 1000)).rejects.toMatchObject(notFound); expect(await calls(c.threadId)).toHaveLength(0); }); it('ASTPROP-004: a hike whose way was not planned cannot be taken; nothing is held', async () => { const problem = { why: 'no_way' as const, position: null, snappedM: null }; const c = await conversation(tourRouteCard({ routed: false, problem })); await expect(take(c, 'h1')).rejects.toMatchObject({ status: 400, code: 'generic' }); expect(await calls(c.threadId)).toHaveLength(0); expect(streams.release).toHaveBeenCalledOnce(); }); it('ASTPROP-005: refused while another change waits, while a turn runs, and past the per-minute limit', async () => { const c = await conversation(); await take(c, 'h1'); await expect(take(c, 'w1')).rejects.toMatchObject({ status: 409, code: 'decide_first' }); streams.claim.mockResolvedValueOnce(false); await expect(take(c, 'w1')).rejects.toMatchObject({ status: 409, code: 'busy' }); rateLimit.check.mockResolvedValueOnce(false); await expect(take(c, 'w1')).rejects.toMatchObject({ status: 429, code: 'too_many_requests' }); expect(await calls(c.threadId)).toHaveLength(1); }); it('ASTPROP-011: a change left waiting past its day holds nothing back, before the nightly sweep marks it', async () => { const c = await conversation(); await take(c, 'h1'); const [stale] = await calls(c.threadId); const dayAndHourAgo = dbNow(new Date(Date.now() - 25 * 60 * 60_000)); await updateRows(t.get(MikroORM), AssistantToolCalls, { id: stale?.id ?? '' }, { created_at: dayAndHourAgo }); await take(c, 'w1'); const held = await calls(c.threadId); expect(held).toHaveLength(2); expect(held.map((call) => call.state)).toEqual(['approval_requested', 'approval_requested']); }); it('ASTPROP-008: a walk stored cut down and masked is created from the tool asked again, named and on no day', async () => { const c = await conversation(); await take(c, 'w1'); const [call] = await calls(c.threadId); const args = JSON.parse(call?.args ?? '{}') as Record; // Never the stored copy: all three stations, none of them masked. expect(args.stations).toEqual(WALK_RESULT.stations_for_create); expect(JSON.stringify(args)).not.toContain('[hidden]'); const card = (JSON.parse(call?.preview ?? '{}') as { card: TourRouteCard }).card; expect(card).toMatchObject({ source: 'pending', activity: 'walk', name: 'Marienplatz → Hofgarten' }); expect(card.stops.map((stop) => stop.name)).toEqual(['Marienplatz', 'Museum', 'Hofgarten']); // create_city_walk puts the walk on no day, so the card names none. expect(card.schedule).toMatchObject({ date: '2026-06-12', dayId: null, dayNumber: null }); }); it('ASTPROP-009: a walk the tool cannot answer now cannot be taken; nothing is held', async () => { const c = await conversation(); session.read.mockImplementation(async (name: string) => name === 'propose_city_walk' ? { ok: false, value: 'Tours are off' } : { ok: true, value: reads[name] }, ); try { await expect(take(c, 'w1')).rejects.toMatchObject({ status: 400, code: 'generic' }); } finally { session.read.mockImplementation(answers); } expect(await calls(c.threadId)).toHaveLength(0); expect(session.close).toHaveBeenCalledOnce(); }); }); describe('what a proposal can be taken as', () => { const card = tourRouteCard(); it('ASTPROP-006: a walk without stations to create, or one its answer says cannot be, gives nothing', () => { const walk = { toolName: 'propose_city_walk', args: {}, card }; expect(takeArgsOf({ ...walk, result: { ...WALK_RESULT, can_create: false } })).toBeNull(); expect(takeArgsOf({ ...walk, result: { stations_for_create: [WALK_RESULT.stations_for_create[0]] } })).toBeNull(); // Stations without names are named by the day and the start. const nameless = WALK_RESULT.stations_for_create.map(({ name: _name, ...station }) => station); expect(takeArgsOf({ ...walk, result: { ...WALK_RESULT, stations_for_create: nameless } })).toMatchObject({ name: '2026-06-12 10:00', }); }); it('ASTPROP-010: a hike asked by date alone is created on no day, and its waiting card names none', () => { const schedule = { date: '2026-06-12', dayId: 32, dayNumber: 2, start: '08:00', arrive: '08:22', nextDay: false, sunrise: null, sunset: null, latestStart: null, weather: null, hours: [], }; const { day_id: _day, ...undated } = HIKE_ARGS; const args = takeArgsOf({ toolName: 'propose_hike', args: { ...undated, date: '2026-06-12' }, result: {}, card }); expect(args).not.toHaveProperty('day_id'); expect(args).not.toHaveProperty('date'); const waiting = pendingCardOf(tourRouteCard({ label: 'the short one', schedule }), args ?? {}); expect(waiting).toMatchObject({ source: 'pending', name: 'Herzogstand', label: null }); expect(waiting.schedule).toEqual({ ...schedule, dayId: null, dayNumber: null }); // On the day the change puts it on, the day stays. expect(pendingCardOf(tourRouteCard({ schedule }), { day_id: 32 }).schedule).toEqual(schedule); }); it('ASTPROP-007: the newest row holding the call wins; a card of another kind is no proposal', () => { const row = (id: number, card: unknown) => ({ id, parts: JSON.stringify([ { type: 'tool-call', toolCallId: 'h1', toolName: 'propose_hike', args: { name: `Hike ${id}` } }, { type: 'data-trek-card', data: { toolCallId: 'h1', card } }, ]), }); const rows = [row(1, card), row(2, { ...card, name: 'Newer' })] as unknown as Parameters[0]; expect(storedProposal(rows, 'h1')).toMatchObject({ toolName: 'propose_hike', args: { name: 'Hike 2' } }); const list = [row(3, { kind: 'tourList', dayId: null, more: 0, rows: [] })] as unknown as typeof rows; expect(storedProposal(list, 'h1')).toBeNull(); }); });