@happyvertical/smrt-chat 0.51.39 → 0.52.0

package/dist/svelte/components/assistant/__tests__/AssistantDock.test.js

@@ -54,7 +54,7 @@ describe('AssistantDock (mounted component)', () => {
         });
         const listThreadsSpy = vi.spyOn(transport, 'listThreads');
         render(AssistantDock, { props: { transport, registry } });
-        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(await screen.findByText(/Nothing on this page can be changed from the chat/i)).toBeInTheDocument();
         expect(listThreadsSpy).toHaveBeenCalledTimes(1);
         // Create + open a thread through the UI, then send a real message
         // through the component's OWN mounted controller.
@@ -75,12 +75,12 @@ describe('AssistantDock (mounted component)', () => {
         // Poll until the notice clears (or fail): the registry event handler
         // runs synchronously, so this should resolve on the very next microtask.
         for (let attempt = 0; attempt < 20; attempt += 1) {
-            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+            if (!screen.queryByText(/Nothing on this page can be changed from the chat/i)) {
                 break;
             }
             await new Promise((resolve) => setTimeout(resolve, 10));
         }
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
         // loadThreads must still have fired only once for the mount — not once
         // per send/poll re-run of a re-triggered effect.
         expect(listThreadsSpy).toHaveBeenCalledTimes(1);
@@ -107,11 +107,11 @@ describe('AssistantDock (mounted component)', () => {
             props: { transport, registry: r1 },
         });
         // R1 has a mounted surface — the empty notice must not show.
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
         // Reassign the prop to a DIFFERENT, empty registry instance (R2).
         const r2 = createDataSurfaceRegistry();
         await rerender({ transport, registry: r2 });
-        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(await screen.findByText(/Nothing on this page can be changed from the chat/i)).toBeInTheDocument();
         // Registering a surface on R2 must be discovered — proves the
         // subscription actually moved to R2, not just a one-time resync.
         const r2Identity = { ...identity, surfaceId: 'products' };
@@ -120,12 +120,12 @@ describe('AssistantDock (mounted component)', () => {
             getSnapshot: () => ({ revision: 1, state: {} }),
         });
         for (let attempt = 0; attempt < 20; attempt += 1) {
-            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+            if (!screen.queryByText(/Nothing on this page can be changed from the chat/i)) {
                 break;
             }
             await new Promise((resolve) => setTimeout(resolve, 10));
         }
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
         // F1 guarantee preserved: the registry-scoped effect must not have
         // caused the SEPARATE mount effect to re-run — but Copilot PR #2919
         // jAwsd's fix means the swap ITSELF now legitimately triggers exactly
@@ -153,7 +153,7 @@ describe('AssistantDock (mounted component)', () => {
         render(AssistantDock, {
             props: { transport, registry, surfaces: [] },
         });
-        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(await screen.findByText(/Nothing on this page can be changed from the chat/i)).toBeInTheDocument();
     });
     // Copilot PR #2919 jAwr0: `surfaces` is a NARROWING filter over the live
     // registry — an override identity that isn't genuinely registered must
@@ -167,7 +167,7 @@ describe('AssistantDock (mounted component)', () => {
         render(AssistantDock, {
             props: { transport, registry, surfaces: [identity] },
         });
-        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(await screen.findByText(/Nothing on this page can be changed from the chat/i)).toBeInTheDocument();
     });
     it('the `surfaces` override makes discovery non-empty only when the identity IS also registered', async () => {
         const registry = createDataSurfaceRegistry();
@@ -179,7 +179,7 @@ describe('AssistantDock (mounted component)', () => {
         render(AssistantDock, {
             props: { transport, registry, surfaces: [identity] },
         });
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
     });
     // Finding 4 (#2904 review, fresh cycle): a failed mount-time listThreads
     // must render as a dock-level error, not an empty, explanation-free
@@ -222,20 +222,20 @@ describe('AssistantDock (mounted component)', () => {
         // Override only includes `products`; the registered `orders` surface is
         // gated out even though it's genuinely registered — the "no surfaces"
         // notice must NOT show (the override list is non-empty).
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
         // Narrow the override to an EMPTY list.
         await rerender({ transport, registry, surfaces: [] });
-        expect(await screen.findByText(/No data surfaces are mounted on this route/i)).toBeInTheDocument();
+        expect(await screen.findByText(/Nothing on this page can be changed from the chat/i)).toBeInTheDocument();
         // Widen back to include the registered `orders` surface — discovery
         // must follow the reassignment and the notice must clear.
         await rerender({ transport, registry, surfaces: [identity] });
         for (let attempt = 0; attempt < 20; attempt += 1) {
-            if (!screen.queryByText(/No data surfaces are mounted on this route/i)) {
+            if (!screen.queryByText(/Nothing on this page can be changed from the chat/i)) {
                 break;
             }
             await new Promise((resolve) => setTimeout(resolve, 10));
         }
-        expect(screen.queryByText(/No data surfaces are mounted on this route/i)).not.toBeInTheDocument();
+        expect(screen.queryByText(/Nothing on this page can be changed from the chat/i)).not.toBeInTheDocument();
     });
     // Cycle-2 second final finding 1: the F1 "mount effect runs exactly once"
     // guarantee must hold even with the new `surfaces`-scoped effect added
@@ -247,7 +247,7 @@ describe('AssistantDock (mounted component)', () => {
         const { rerender } = render(AssistantDock, {
             props: { transport, registry, surfaces: [] },
         });
-        await screen.findByText(/No data surfaces are mounted on this route/i);
+        await screen.findByText(/Nothing on this page can be changed from the chat/i);
         await rerender({ transport, registry, surfaces: [identity] });
         await rerender({ transport, registry, surfaces: [] });
         expect(listThreadsSpy).toHaveBeenCalledTimes(1);
@@ -264,7 +264,7 @@ describe('AssistantDock (mounted component)', () => {
             throw new Error('no writeEndpoint configured');
         };
         render(AssistantDock, { props: { transport, registry } });
-        await screen.findByText(/No data surfaces are mounted on this route/i);
+        await screen.findByText(/Nothing on this page can be changed from the chat/i);
         await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
         expect(await screen.findByText(/Something went wrong: no writeEndpoint configured/i)).toBeInTheDocument();
     });

package/dist/svelte/components/assistant/__tests__/assistant-composer-dictation.test.js

@@ -0,0 +1,197 @@
+// @vitest-environment jsdom
+/**
+ * Speaking into the assistant composer (smrt-ui `Dictation` over a mocked
+ * speech source; real speech recognition cannot run headless): a named
+ * microphone button, press-and-hold on the message box, heard words at the
+ * cursor, and Send / Escape stopping it. No source means no microphone.
+ */
+import { fireEvent, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import AssistantChoiceCards from '../AssistantChoiceCards.svelte';
+import AssistantComposer from '../AssistantComposer.svelte';
+function mockSpeech() {
+    const results = new Set();
+    const ends = new Set();
+    const source = {
+        start: vi.fn(async () => { }),
+        stop: vi.fn(async () => {
+            for (const cb of ends)
+                cb();
+        }),
+        onResult: (cb) => {
+            results.add(cb);
+            return () => results.delete(cb);
+        },
+        onError: () => () => { },
+        onEnd: (cb) => {
+            ends.add(cb);
+            return () => ends.delete(cb);
+        },
+    };
+    return {
+        source,
+        say(text) {
+            for (const cb of results)
+                cb({ text, isFinal: true });
+        },
+    };
+}
+function pointerEvent(type, init = {}) {
+    const event = new Event(type, { bubbles: true, cancelable: true });
+    Object.assign(event, {
+        isPrimary: true,
+        pointerId: 3,
+        pointerType: 'touch',
+        button: 0,
+        clientX: 20,
+        clientY: 20,
+        ...init,
+    });
+    return event;
+}
+describe('AssistantComposer dictation', () => {
+    afterEach(() => vi.useRealTimers());
+    it('has no microphone without a speech source', () => {
+        render(AssistantComposer, {
+            props: { onsend: vi.fn(), onupload: vi.fn() },
+        });
+        expect(screen.queryByRole('button', { name: 'Speak instead of typing' })).toBeNull();
+    });
+    it('the microphone listens and puts heard words at the cursor; Send stops it', async () => {
+        const speech = mockSpeech();
+        const onsend = vi.fn().mockResolvedValue(undefined);
+        render(AssistantComposer, {
+            props: { onsend, onupload: vi.fn(), dictation: () => speech.source },
+        });
+        const field = screen.getByLabelText('Message');
+        await userEvent.type(field, 'Find a picture of');
+        await userEvent.click(screen.getByRole('button', { name: 'Speak instead of typing' }));
+        expect(await screen.findByRole('button', { name: 'Stop listening' })).toHaveAttribute('aria-pressed', 'true');
+        expect(screen.getByRole('status')).toHaveTextContent('Listening');
+        speech.say('the arena');
+        expect(field).toHaveValue('Find a picture of the arena');
+        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        expect(onsend).toHaveBeenCalledWith('Find a picture of the arena', []);
+        expect(speech.source.stop).toHaveBeenCalled();
+    });
+    it('pressing and holding the message box starts listening; Escape stops', async () => {
+        vi.useFakeTimers({ shouldAdvanceTime: true });
+        const speech = mockSpeech();
+        render(AssistantComposer, {
+            props: {
+                onsend: vi.fn(),
+                onupload: vi.fn(),
+                dictation: () => speech.source,
+            },
+        });
+        const field = screen.getByLabelText('Message');
+        field.dispatchEvent(pointerEvent('pointerdown'));
+        vi.advanceTimersByTime(520);
+        window.dispatchEvent(pointerEvent('pointerup'));
+        await vi.waitFor(() => expect(speech.source.start).toHaveBeenCalled());
+        expect(await screen.findByRole('button', { name: 'Stop listening' })).toBeInTheDocument();
+        await fireEvent.keyDown(field, { key: 'Escape' });
+        await vi.waitFor(() => expect(speech.source.stop).toHaveBeenCalled());
+    });
+    it('a short tap on the message box does not listen', async () => {
+        vi.useFakeTimers({ shouldAdvanceTime: true });
+        const speech = mockSpeech();
+        render(AssistantComposer, {
+            props: {
+                onsend: vi.fn(),
+                onupload: vi.fn(),
+                dictation: () => speech.source,
+            },
+        });
+        const field = screen.getByLabelText('Message');
+        field.dispatchEvent(pointerEvent('pointerdown'));
+        vi.advanceTimersByTime(150);
+        window.dispatchEvent(pointerEvent('pointerup'));
+        vi.advanceTimersByTime(800);
+        expect(speech.source.start).not.toHaveBeenCalled();
+    });
+});
+describe('AssistantChoiceCards', () => {
+    it('renders offered options and reports the pick and "None of these"', async () => {
+        const onchoose = vi.fn();
+        const ondismiss = vi.fn();
+        render(AssistantChoiceCards, {
+            props: {
+                choices: [
+                    {
+                        id: 's1',
+                        sourceId: 'crop',
+                        title: 'Pick a shape',
+                        status: 'waiting',
+                        options: [
+                            { id: 'wide', label: 'Wide' },
+                            { id: 'square', label: 'Square' },
+                        ],
+                    },
+                ],
+                onchoose,
+                ondismiss,
+            },
+        });
+        await userEvent.click(screen.getByRole('button', { name: 'Square' }));
+        expect(onchoose).toHaveBeenCalledWith('s1', 'square');
+        await userEvent.click(screen.getByRole('button', { name: 'None of these' }));
+        expect(ondismiss).toHaveBeenCalledWith('s1');
+    });
+});
+describe('AssistantComposer recording fallback', () => {
+    afterEach(() => vi.unstubAllGlobals());
+    function stubRecorder() {
+        class FakeMediaRecorder extends EventTarget {
+            static isTypeSupported = (type) => type === 'audio/webm;codecs=opus';
+            state = 'inactive';
+            mimeType;
+            constructor(_stream, options) {
+                super();
+                this.mimeType = options?.mimeType ?? '';
+            }
+            start() {
+                this.state = 'recording';
+            }
+            stop() {
+                this.state = 'inactive';
+                this.dispatchEvent(Object.assign(new Event('dataavailable'), {
+                    data: new Blob(['opus'], { type: this.mimeType }),
+                }));
+                this.dispatchEvent(new Event('stop'));
+            }
+        }
+        const track = { stop: vi.fn() };
+        vi.stubGlobal('MediaRecorder', FakeMediaRecorder);
+        Object.defineProperty(navigator, 'mediaDevices', {
+            configurable: true,
+            value: {
+                getUserMedia: vi.fn(async () => ({ getTracks: () => [track] })),
+            },
+        });
+        return track;
+    }
+    it('records with only `transcribe` (Firefox), writes it down, and puts the text in the box', async () => {
+        const track = stubRecorder();
+        let finish;
+        const transcribe = vi.fn(() => new Promise((resolve) => (finish = resolve)));
+        render(AssistantComposer, {
+            props: { onsend: vi.fn(), onupload: vi.fn(), transcribe },
+        });
+        const mic = screen.getByRole('button', { name: 'Speak instead of typing' });
+        await userEvent.click(mic);
+        await screen.findByText(/Listening/);
+        await userEvent.click(screen.getByRole('button', { name: 'Stop listening' }));
+        await screen.findByText('Writing it down…');
+        expect(track.stop).toHaveBeenCalled();
+        expect(transcribe).toHaveBeenCalledWith(expect.any(Blob), {
+            mimeType: 'audio/webm;codecs=opus',
+            language: expect.any(String),
+            durationMs: expect.any(Number),
+            signal: expect.any(AbortSignal),
+        });
+        finish('Show me the arena');
+        const box = screen.getByRole('textbox', { name: /message/i });
+        await vi.waitFor(() => expect(box.value).toBe('Show me the arena'));
+    });
+});

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

@@ -0,0 +1,224 @@
+// @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();
+    });
+});