@happyvertical/smrt-chat 0.53.0 → 0.53.2

package/dist/svelte/components/assistant/__tests__/assistant-dock-choices-pending.test.js

@@ -1,224 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Choices whose options take a while (generated pictures): the offer shows
- * "Making…" placeholders, options are added as they finish, the person can
- * pick any that arrived, and a failure is said plainly.
- */
-import { createDataSurfaceRegistry } from '@happyvertical/smrt-ui/data-surface';
-import { render, screen, userEvent } from '@happyvertical/smrt-vitest/svelte';
-import { describe, expect, it, vi } from 'vitest';
-import AssistantDock from '../AssistantDock.svelte';
-import { choiceToolName, createAssistantChoiceSourceRegistry, } from '../assistant-choices.svelte.js';
-import { createAssistantDockController } from '../create-assistant-dock-controller.svelte.js';
-function message(id, role, content) {
-    return {
-        id,
-        threadId: 't1',
-        role,
-        content,
-        createdAt: new Date(0).toISOString(),
-    };
-}
-/** Every send asks for one choice tool call; resuming answers in text. */
-function transportCalling(call) {
-    const resumed = [];
-    let sends = 0;
-    const transport = {
-        resumed,
-        async listThreads() {
-            return [{ id: 't1', title: 'T', isResolved: false, messageCount: 0 }];
-        },
-        async createThread() {
-            return { id: 't1', title: 'T', isResolved: false, messageCount: 0 };
-        },
-        async loadMessages() {
-            return [];
-        },
-        async uploadAttachment() {
-            throw new Error('no');
-        },
-        async sendMessage(input) {
-            sends += 1;
-            return {
-                inProgress: false,
-                userMessage: message(`u${sends}`, 'user', input.content),
-                clientToolCalls: {
-                    continuationId: `cont-${sends}`,
-                    calls: [{ ...call, id: sends > 1 ? `${call.id}-${sends}` : call.id }],
-                },
-            };
-        },
-        async resumeTurn(input) {
-            resumed.push(input);
-            return {
-                inProgress: false,
-                assistantMessage: message('a1', 'assistant', 'Making them now.'),
-            };
-        },
-    };
-    return transport;
-}
-/** A source whose versions arrive when the test says so. */
-function slowSource() {
-    let update;
-    let signal;
-    let finish = () => { };
-    const apply = vi.fn(async () => 'Used the snowy one.');
-    const source = {
-        id: 'picture_edit',
-        description: 'Make new versions of the picture.',
-        offer: () => ({
-            title: 'Snowy versions',
-            options: [],
-            pending: {
-                message: 'Making versions… this takes a minute or two.',
-                expected: 3,
-                fill: (u, s) => new Promise((resolve, reject) => {
-                    update = u;
-                    signal = s;
-                    finish = (err) => (err ? reject(err) : resolve());
-                }),
-            },
-        }),
-        apply,
-    };
-    return {
-        source,
-        apply,
-        add: (id) => update?.add([{ id, label: `Version ${id}`, imageUrl: `/v/${id}.jpg` }]),
-        finish: (err) => finish(err),
-        signal: () => signal,
-    };
-}
-async function until(check) {
-    for (let i = 0; i < 50 && !check(); i += 1) {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-}
-async function offered(slow) {
-    const registry = createAssistantChoiceSourceRegistry();
-    registry.register(slow.source);
-    const transport = transportCalling({
-        id: 'e1',
-        name: choiceToolName('picture_edit'),
-        args: {},
-        effect: 'read',
-    });
-    const controller = createAssistantDockController({
-        transport,
-        registry: createDataSurfaceRegistry(),
-        choiceSources: registry,
-    });
-    await controller.loadThreads();
-    await controller.openThread('t1');
-    await controller.send('make it snowing');
-    await until(() => Boolean(slow.signal()));
-    return { controller, transport };
-}
-describe('pending choices', () => {
-    it('tells the model versions are coming, fills them in, and applies the pick', async () => {
-        const slow = slowSource();
-        const { controller, transport } = await offered(slow);
-        expect(JSON.parse(transport.resumed[0].results[0].result ?? '{}')).toEqual({
-            offered: true,
-            waitingForUser: true,
-            stillMaking: true,
-            progress: 'Making versions… this takes a minute or two.',
-            options: [],
-        });
-        expect(controller.choices[0]).toMatchObject({
-            status: 'waiting',
-            pending: { expected: 3 },
-        });
-        expect(controller.status.label).toBe('Making versions… this takes a minute or two.');
-        slow.add('a');
-        expect(controller.choices[0].options.map((o) => o.id)).toEqual(['a']);
-        expect(controller.choices[0].pending?.expected).toBe(2);
-        expect(controller.status.label).toBe('Pick one of the options');
-        // The person picks the first version while the others are still coming.
-        await controller.chooseOption('e1', 'a');
-        expect(slow.apply).toHaveBeenCalledTimes(1);
-        expect(controller.choices[0]).toMatchObject({ status: 'applied' });
-        expect(controller.choices[0].pending).toBeUndefined();
-        expect(slow.signal()?.aborted).toBe(true);
-        // Late versions are ignored.
-        slow.add('b');
-        expect(controller.choices[0].options).toHaveLength(1);
-    });
-    it('keeps the offer when the person sends another message; None of these stops it', async () => {
-        const slow = slowSource();
-        const { controller } = await offered(slow);
-        const firstSignal = slow.signal();
-        await controller.send('thanks');
-        expect(controller.choices[0]).toMatchObject({
-            id: 'e1',
-            status: 'waiting',
-        });
-        expect(firstSignal?.aborted).toBe(false);
-        controller.dismissChoices('e1');
-        expect(controller.choices[0].status).toBe('dismissed');
-        expect(firstSignal?.aborted).toBe(true);
-    });
-    it('ends ready with what arrived, and notes a partial failure', async () => {
-        const slow = slowSource();
-        const { controller } = await offered(slow);
-        slow.add('a');
-        slow.add('b');
-        slow.finish(new Error('One version could not be made.'));
-        await until(() => !controller.choices[0].pending);
-        expect(controller.choices[0]).toMatchObject({
-            status: 'waiting',
-            note: 'One version could not be made.',
-        });
-        expect(controller.choices[0].options).toHaveLength(2);
-    });
-    it('is unavailable, and holds nothing, when no version could be made', async () => {
-        const slow = slowSource();
-        const { controller } = await offered(slow);
-        slow.finish(new Error('The picture service is busy. Try again later.'));
-        await until(() => controller.choices[0].status !== 'waiting');
-        expect(controller.choices[0]).toMatchObject({
-            status: 'unavailable',
-            error: 'The picture service is busy. Try again later.',
-        });
-        expect(controller.status.label).not.toBe('Pick one of the options');
-    });
-    it('shows placeholders, then the versions as cards', async () => {
-        const slow = slowSource();
-        const registry = createAssistantChoiceSourceRegistry();
-        registry.register(slow.source);
-        const transport = transportCalling({
-            id: 'e1',
-            name: 'assistant_offer_picture_edit',
-            args: {},
-            effect: 'read',
-        });
-        let controller;
-        render(AssistantDock, {
-            props: {
-                transport,
-                registry: createDataSurfaceRegistry(),
-                choiceSources: registry,
-                oncontroller: (c) => {
-                    controller = c;
-                },
-            },
-        });
-        await until(() => Boolean(controller));
-        await controller?.openThread('t1');
-        await controller?.send('make it snowing');
-        const group = await screen.findByRole('group', { name: 'Snowy versions' });
-        expect(group.getAttribute('aria-busy')).toBe('true');
-        expect(screen.getAllByText('Making…')).toHaveLength(3);
-        expect(screen.getAllByText('Making versions… this takes a minute or two.')
-            .length).toBeGreaterThan(0);
-        slow.add('a');
-        await screen.findByRole('button', { name: /Version a/ });
-        expect(screen.getAllByText('Making…')).toHaveLength(2);
-        slow.finish();
-        await until(() => screen.queryAllByText('Making…').length === 0);
-        expect(group.getAttribute('aria-busy')).toBeNull();
-        await userEvent.click(screen.getByRole('button', { name: /Version a/ }));
-        expect(await screen.findByText('Used the snowy one.')).toBeTruthy();
-    });
-});

package/dist/svelte/components/assistant/__tests__/assistant-dock-choices-preview.test.js

@@ -1,312 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Previewable choices: a click previews a card in place (nothing applied),
- * another click swaps the preview, "Original" shows the page as it was, and
- * only the commit button applies. Cancel, Escape, dismissing and disposing
- * restore the original.
- */
-import { createDataSurfaceRegistry } from '@happyvertical/smrt-ui/data-surface';
-import { render, screen, userEvent } from '@happyvertical/smrt-vitest/svelte';
-import { describe, expect, it, vi } from 'vitest';
-import AssistantDock from '../AssistantDock.svelte';
-import { createAssistantChoiceSourceRegistry, } from '../assistant-choices.svelte.js';
-function message(id, role, content) {
-    return {
-        id,
-        threadId: 't1',
-        role,
-        content,
-        createdAt: new Date(0).toISOString(),
-    };
-}
-function suspendingTransport(calls) {
-    const sent = [];
-    const resumed = [];
-    const transport = {
-        sent,
-        resumed,
-        async listThreads() {
-            return [{ id: 't1', title: 'T', isResolved: false, messageCount: 0 }];
-        },
-        async createThread() {
-            return { id: 't1', title: 'T', isResolved: false, messageCount: 0 };
-        },
-        async loadMessages() {
-            return [];
-        },
-        async uploadAttachment() {
-            throw new Error('no');
-        },
-        async sendMessage(input) {
-            sent.push(input);
-            return {
-                inProgress: false,
-                userMessage: message('u1', 'user', input.content),
-                clientToolCalls: {
-                    continuationId: `cont-${sent.length}`,
-                    calls: calls.map((call) => ({
-                        ...call,
-                        id: sent.length > 1 ? `${call.id}-${sent.length}` : call.id,
-                    })),
-                },
-            };
-        },
-        async resumeTurn(input) {
-            resumed.push(input);
-            const reply = message('a1', 'assistant', 'Pick one of these.');
-            return { inProgress: false, assistantMessage: reply };
-        },
-    };
-    return transport;
-}
-async function until(check) {
-    for (let i = 0; i < 50 && !check(); i += 1) {
-        await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-}
-const ORIGINAL = { id: 'original', label: 'Original', imageUrl: '/p/1?orig' };
-function previewSource() {
-    const shown = [];
-    const apply = vi.fn(async () => 'Changed it.');
-    const source = {
-        id: 'picture_adjust',
-        description: 'Quick changes.',
-        offer: async () => ({
-            title: 'Pick a version',
-            options: [
-                { id: 'a', label: 'Brighter', imageUrl: '/p/1?a' },
-                { id: 'b', label: 'Much brighter', imageUrl: '/p/1?b' },
-            ],
-            original: ORIGINAL,
-            commitLabel: 'Use this picture',
-            cancelLabel: 'Keep the original',
-        }),
-        apply,
-        preview: (option) => {
-            shown.push(option?.id === 'original' || !option ? null : (option.imageUrl ?? null));
-        },
-    };
-    return { source, shown, apply };
-}
-async function mount(source) {
-    const registry = createAssistantChoiceSourceRegistry();
-    registry.register(source);
-    const transport = suspendingTransport([
-        {
-            id: 'c1',
-            name: 'assistant_offer_picture_adjust',
-            args: {},
-            effect: 'read',
-        },
-    ]);
-    let controller;
-    const view = render(AssistantDock, {
-        props: {
-            transport,
-            registry: createDataSurfaceRegistry(),
-            choiceSources: registry,
-            oncontroller: (c) => {
-                controller = c;
-            },
-        },
-    });
-    await until(() => Boolean(controller));
-    await controller?.openThread('t1');
-    await controller?.send('brighter');
-    await screen.findByRole('group', { name: 'Pick a version' });
-    return { controller: controller, view };
-}
-describe('previewable choices', () => {
-    it('previews a click, swaps the preview, shows the original, and applies nothing', async () => {
-        const { source, shown, apply } = previewSource();
-        const { controller } = await mount(source);
-        // The Original card comes first.
-        const cards = screen
-            .getAllByRole('button')
-            .filter((b) => b.hasAttribute('aria-pressed'));
-        expect(cards.map((b) => b.textContent?.trim())).toEqual([
-            'Original',
-            'Brighter',
-            'Much brighter',
-        ]);
-        await userEvent.click(screen.getByRole('button', { name: /^Brighter/ }));
-        await until(() => shown.length === 1);
-        expect(shown).toEqual(['/p/1?a']);
-        expect(screen
-            .getByRole('button', { name: /^Brighter/ })
-            .getAttribute('aria-pressed')).toBe('true');
-        await userEvent.click(screen.getByRole('button', { name: /^Much brighter/ }));
-        await until(() => shown.length === 2);
-        expect(shown).toEqual(['/p/1?a', '/p/1?b']);
-        expect(screen
-            .getByRole('button', { name: /^Brighter/ })
-            .getAttribute('aria-pressed')).toBe('false');
-        await userEvent.click(screen.getByRole('button', { name: /^Original/ }));
-        await until(() => shown.length === 3);
-        expect(shown).toEqual(['/p/1?a', '/p/1?b', null]);
-        expect(apply).not.toHaveBeenCalled();
-        expect(controller.choices[0].status).toBe('waiting');
-    });
-    it('keeps the commit button off until a version is previewed, then applies only the previewed one and resolves', async () => {
-        const { source, apply } = previewSource();
-        const { controller } = await mount(source);
-        const use = screen.getByRole('button', {
-            name: 'Use this picture',
-        });
-        expect(use.disabled).toBe(true);
-        await userEvent.click(screen.getByRole('button', { name: /^Much brighter/ }));
-        await until(() => !use.disabled);
-        expect(use.disabled).toBe(false);
-        await userEvent.click(use);
-        await until(() => apply.mock.calls.length > 0);
-        expect(apply).toHaveBeenCalledTimes(1);
-        expect(apply).toHaveBeenCalledWith(expect.objectContaining({ id: 'b' }));
-        expect(await screen.findByText('Changed it.')).toBeTruthy();
-        expect(controller.choices[0]).toMatchObject({
-            status: 'applied',
-            chosenOptionId: 'b',
-        });
-        // The cards collapse once resolved.
-        expect(screen.queryByRole('button', { name: /^Brighter/ })).toBeNull();
-    });
-    it('waits for a slow preview: cards and commit are off until the page shows it', async () => {
-        const { source, apply } = previewSource();
-        const releases = [];
-        const shown = [];
-        const slow = {
-            ...source,
-            preview: (option) => new Promise((resolve) => {
-                releases.push(() => {
-                    shown.push(option?.id ?? 'none');
-                    resolve();
-                });
-            }),
-        };
-        const { controller } = await mount(slow);
-        const brighter = screen.getByRole('button', { name: /^Brighter/ });
-        const muchBrighter = screen.getByRole('button', {
-            name: /^Much brighter/,
-        });
-        const use = screen.getByRole('button', {
-            name: 'Use this picture',
-        });
-        await userEvent.click(brighter);
-        await until(() => releases.length === 1);
-        // While the page is still changing, nothing else can be picked or committed.
-        expect(muchBrighter.disabled).toBe(true);
-        expect(use.disabled).toBe(true);
-        await userEvent.click(muchBrighter);
-        expect(releases).toHaveLength(1);
-        releases[0]();
-        await until(() => !muchBrighter.disabled);
-        expect(shown).toEqual(['a']);
-        expect(controller.choices[0].previewOptionId).toBe('a');
-        expect(use.disabled).toBe(false);
-        await userEvent.click(use);
-        await until(() => apply.mock.calls.length > 0);
-        expect(apply).toHaveBeenCalledWith(expect.objectContaining({ id: 'a' }));
-    });
-    it('back-to-back previews queue, the last one shows, and it is what commits', async () => {
-        const { source, apply } = previewSource();
-        const shown = [];
-        const releases = [];
-        const slow = {
-            ...source,
-            preview: (option) => new Promise((resolve) => {
-                releases.push(() => {
-                    shown.push(option?.id ?? 'none');
-                    resolve();
-                });
-            }),
-        };
-        const { controller } = await mount(slow);
-        const setId = controller.choices[0].id;
-        // Two programmatic previews (a double click that beat the disabled
-        // state): they queue, a superseded one never reaches the page, the page
-        // and the offer both end on the second, and a commit while a preview is
-        // pending does nothing.
-        const first = controller.previewOption(setId, 'a');
-        const second = controller.previewOption(setId, 'b');
-        await until(() => releases.length === 1);
-        await controller.commitOption(setId);
-        expect(apply).not.toHaveBeenCalled();
-        releases[0]();
-        await Promise.all([first, second]);
-        expect(releases).toHaveLength(1);
-        expect(shown).toEqual(['b']);
-        expect(controller.choices[0].previewOptionId).toBe('b');
-        expect(controller.choices[0].previewPendingId).toBeUndefined();
-        await controller.commitOption(setId);
-        expect(apply).toHaveBeenCalledTimes(1);
-        expect(apply).toHaveBeenCalledWith(expect.objectContaining({ id: 'b' }));
-    });
-    it('cancelling during a slow preview restores the page after it, never before', async () => {
-        const { source } = previewSource();
-        const shown = [];
-        const releases = [];
-        const slow = {
-            ...source,
-            preview: (option) => new Promise((resolve) => {
-                releases.push(() => {
-                    shown.push(option?.id === 'original' || !option ? null : option.id);
-                    resolve();
-                });
-            }),
-        };
-        const { controller } = await mount(slow);
-        const setId = controller.choices[0].id;
-        const pending = controller.previewOption(setId, 'a');
-        await until(() => releases.length === 1);
-        await userEvent.click(screen.getByRole('button', { name: 'Keep the original' }));
-        releases[0]();
-        await pending;
-        await until(() => releases.length === 2);
-        releases[1]();
-        await until(() => shown.length === 2);
-        expect(shown).toEqual(['a', null]);
-        expect(controller.choices[0].status).toBe('dismissed');
-    });
-    it('cancel restores the original and closes without applying', async () => {
-        const { source, shown, apply } = previewSource();
-        await mount(source);
-        await userEvent.click(screen.getByRole('button', { name: /^Brighter/ }));
-        await until(() => shown.length === 1);
-        await userEvent.click(screen.getByRole('button', { name: 'Keep the original' }));
-        await until(() => shown.length === 2);
-        expect(shown).toEqual(['/p/1?a', null]);
-        expect(screen.queryByRole('group', { name: 'Pick a version' })).toBeNull();
-        expect(apply).not.toHaveBeenCalled();
-    });
-    it('Escape cancels an open preview', async () => {
-        const { source, shown, apply } = previewSource();
-        await mount(source);
-        const card = screen.getByRole('button', { name: /^Brighter/ });
-        await userEvent.click(card);
-        await until(() => shown.length === 1);
-        card.focus();
-        await userEvent.keyboard('{Escape}');
-        await until(() => shown.length === 2);
-        expect(shown).toEqual(['/p/1?a', null]);
-        expect(screen.queryByRole('group', { name: 'Pick a version' })).toBeNull();
-        expect(apply).not.toHaveBeenCalled();
-    });
-    it('puts the page back when the conversation is disposed with an uncommitted preview', async () => {
-        const { source, shown, apply } = previewSource();
-        const { controller } = await mount(source);
-        await userEvent.click(screen.getByRole('button', { name: /^Brighter/ }));
-        await until(() => shown.length === 1);
-        controller.dispose();
-        await until(() => shown.length === 2);
-        expect(shown).toEqual(['/p/1?a', null]);
-        expect(apply).not.toHaveBeenCalled();
-    });
-    it('a source without preview still applies on click', async () => {
-        const apply = vi.fn(async () => 'Done.');
-        const { source } = previewSource();
-        await mount({ ...source, preview: undefined, apply });
-        await userEvent.click(screen.getByRole('button', { name: /^Brighter/ }));
-        await until(() => apply.mock.calls.length > 0);
-        expect(apply).toHaveBeenCalledTimes(1);
-        expect(screen.queryByRole('button', { name: 'Use this picture' })).toBeNull();
-    });
-});