@happyvertical/smrt-chat 0.53.1 → 0.53.2

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

@@ -1,197 +0,0 @@
-// @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-action-outcome.test.js

@@ -1,320 +0,0 @@
-// @vitest-environment jsdom
-/**
- * #2990: an apply that reached no server decision ("unknown outcome") is kept
- * apart from a refusal, keeps its idempotency key, and can only be retried
- * with that same key — never discarded or re-proposed under a fresh one.
- *
- * `idempotentServer` models the server adapter's contract: the first apply
- * for a key commits and records its result; any later apply with the same
- * key replays that result without committing again, and a different key is
- * a new mutation. `commits` is the double-apply oracle.
- */
-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 { createInMemoryAssistantTransport } from '../assistant-transport.js';
-import { ASSISTANT_ACTION_UNKNOWN_OUTCOME_REASONS, createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
-const identity = {
-    surfaceId: 'orders',
-    kind: 'table',
-    subject: { type: 'tenant', id: 'tenant-a' },
-};
-function registryWithSurface() {
-    const registry = createDataSurfaceRegistry();
-    const descriptor = {
-        version: 1,
-        identity,
-        schemaVersion: 1,
-        label: 'Orders',
-        rowKey: 'id',
-        columns: [
-            { id: 'id', label: 'ID', capabilities: ['read'], role: 'row-key' },
-        ],
-        query: {
-            modes: ['rows'],
-            projectableColumnIds: ['id'],
-            searchableColumnIds: [],
-            filterableColumnIds: [],
-            sortableColumnIds: [],
-        },
-        actions: [],
-        controls: [],
-        limits: { maxQueryRows: 10, maxQueryBytes: 10_000, maxSelectionSize: 10 },
-    };
-    registry.register({
-        descriptor,
-        getSnapshot: () => ({ revision: 1, state: {} }),
-    });
-    return registry;
-}
-const REQUEST_ID = 'req-ship';
-function proposal() {
-    return {
-        version: 1,
-        requestId: REQUEST_ID,
-        identity,
-        actionId: 'ship',
-        phase: 'preview',
-        selection: { scope: 'explicit-ids', rowIds: ['order-1'] },
-    };
-}
-function result(request, phase, ok, reason) {
-    return {
-        version: 1,
-        requestId: request.requestId,
-        identity: request.identity,
-        actionId: request.actionId,
-        phase,
-        ok,
-        ...(reason ? { reason } : {}),
-    };
-}
-function idempotentServer() {
-    const byKey = new Map();
-    const server = {
-        commits: 0,
-        applyCalls: 0,
-        keys: [],
-        mode: 'commit',
-        gate: undefined,
-        preview: vi.fn(async (request) => result(request, 'preview', true)),
-        client: undefined,
-    };
-    server.client = {
-        preview: server.preview,
-        apply: async (request, key) => {
-            server.applyCalls += 1;
-            server.keys.push(key);
-            if (server.gate)
-                await server.gate;
-            const replay = byKey.get(key);
-            if (replay)
-                return replay;
-            if (server.mode === 'in-progress') {
-                return result(request, 'apply', false, 'idempotency_in_progress');
-            }
-            server.commits += 1;
-            const applied = result(request, 'apply', true);
-            byKey.set(key, applied);
-            if (server.mode === 'commit-then-lose-response') {
-                throw new Error('network: response lost');
-            }
-            return applied;
-        },
-    };
-    return server;
-}
-function setup(server = idempotentServer()) {
-    const onActionApplied = vi.fn();
-    const controller = createAssistantDockController({
-        transport: createInMemoryAssistantTransport(),
-        registry: registryWithSurface(),
-        actionClient: server.client,
-        onActionApplied,
-    });
-    return { controller, server, onActionApplied };
-}
-async function previewed(controller) {
-    await controller.previewAction(proposal());
-    expect(controller.actions.get(REQUEST_ID)?.status).toBe('previewed');
-    return controller.actions.get(REQUEST_ID)?.idempotencyKey;
-}
-describe('unknown apply outcome vs refusal (#2990)', () => {
-    it('marks a rejected apply (transport failure) as an unknown outcome and keeps its key', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        const state = controller.actions.get(REQUEST_ID);
-        expect(state?.status).toBe('failed');
-        expect(state?.outcomeUnknown).toBe(true);
-        expect(state?.retryable).toBe(true);
-        expect(state?.idempotencyKey).toBe(key);
-        controller.dispose();
-    });
-    it.each(ASSISTANT_ACTION_UNKNOWN_OUTCOME_REASONS)('treats ok:false with reason %s as an unknown outcome', async (reason) => {
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: {
-                preview: async (request) => result(request, 'preview', true),
-                apply: async (request) => result(request, 'apply', false, reason),
-            },
-        });
-        await previewed(controller);
-        await controller.applyAction(REQUEST_ID);
-        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
-        controller.dispose();
-    });
-    it.each([
-        'denied',
-        'not_found',
-        'idempotency_conflict',
-        'stale_revision',
-        'confirmation_required',
-        'confirmation_mismatch',
-    ])('treats ok:false with reason %s as a refusal', async (reason) => {
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: {
-                preview: async (request) => result(request, 'preview', true),
-                apply: async (request) => result(request, 'apply', false, reason),
-            },
-        });
-        await previewed(controller);
-        await controller.applyAction(REQUEST_ID);
-        const state = controller.actions.get(REQUEST_ID);
-        expect(state?.status).toBe('failed');
-        expect(state?.outcomeUnknown).toBe(false);
-        // A refusal is terminal, so discarding it is allowed.
-        controller.rejectAction(REQUEST_ID);
-        expect(controller.actions.has(REQUEST_ID)).toBe(false);
-        controller.dispose();
-    });
-});
-describe('an unknown outcome cannot be discarded or re-keyed (#2990)', () => {
-    it('refuses rejectAction and keeps the entry and key', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        controller.rejectAction(REQUEST_ID);
-        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
-        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
-        expect(controller.error).toMatch(/rejectAction refused/);
-        controller.dispose();
-    });
-    it('refuses a new previewAction for the same request id', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        server.preview.mockClear();
-        await controller.previewAction(proposal());
-        expect(server.preview).not.toHaveBeenCalled();
-        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
-        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
-        expect(controller.error).toMatch(/previewAction refused/);
-        controller.dispose();
-    });
-    it('refuses a new previewAction while an apply is in flight', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        let release;
-        server.gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        const applying = controller.applyAction(REQUEST_ID);
-        await controller.previewAction(proposal());
-        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applying');
-        expect(controller.actions.get(REQUEST_ID)?.idempotencyKey).toBe(key);
-        release();
-        await applying;
-        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
-        expect(server.commits).toBe(1);
-        controller.dispose();
-    });
-});
-describe('same-key retry after an unknown outcome (#2990)', () => {
-    it('replays with the same key, applies exactly once, and clears the flag', async () => {
-        const { controller, server, onActionApplied } = setup();
-        const key = await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        expect(server.commits).toBe(1);
-        // The operator tries every discard/re-propose path, then retries.
-        controller.rejectAction(REQUEST_ID);
-        await controller.previewAction(proposal());
-        server.mode = 'commit';
-        await controller.applyAction(REQUEST_ID);
-        const state = controller.actions.get(REQUEST_ID);
-        expect(state?.status).toBe('applied');
-        expect(state?.outcomeUnknown).toBe(false);
-        expect(server.keys).toEqual([key, key]);
-        expect(server.commits).toBe(1);
-        expect(onActionApplied).toHaveBeenCalledTimes(1);
-        controller.dispose();
-    });
-    it('keeps the key through idempotency_in_progress until the first attempt settles', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        server.mode = 'in-progress';
-        await controller.applyAction(REQUEST_ID);
-        await controller.applyAction(REQUEST_ID);
-        expect(controller.actions.get(REQUEST_ID)?.outcomeUnknown).toBe(true);
-        server.mode = 'commit';
-        await controller.applyAction(REQUEST_ID);
-        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
-        expect(new Set(server.keys)).toEqual(new Set([key]));
-        expect(server.commits).toBe(1);
-        controller.dispose();
-    });
-    it('coalesces concurrent duplicate retries into one in-flight apply', async () => {
-        const { controller, server } = setup();
-        const key = await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        server.mode = 'commit';
-        let release;
-        server.gate = new Promise((resolve) => {
-            release = resolve;
-        });
-        const callsBefore = server.applyCalls;
-        const retries = [
-            controller.applyAction(REQUEST_ID),
-            controller.applyAction(REQUEST_ID),
-            controller.applyAction(REQUEST_ID),
-        ];
-        controller.rejectAction(REQUEST_ID);
-        release();
-        await Promise.all(retries);
-        expect(server.applyCalls - callsBefore).toBe(1);
-        expect(server.keys.every((k) => k === key)).toBe(true);
-        expect(server.commits).toBe(1);
-        expect(controller.actions.get(REQUEST_ID)?.status).toBe('applied');
-        controller.dispose();
-    });
-    it('refuses a duplicate retry once the action is applied', async () => {
-        const { controller, server } = setup();
-        await previewed(controller);
-        server.mode = 'commit-then-lose-response';
-        await controller.applyAction(REQUEST_ID);
-        server.mode = 'commit';
-        await controller.applyAction(REQUEST_ID);
-        const calls = server.applyCalls;
-        await controller.applyAction(REQUEST_ID);
-        expect(server.applyCalls).toBe(calls);
-        expect(server.commits).toBe(1);
-        controller.dispose();
-    });
-});
-describe('AssistantDock unknown-outcome affordance (#2990)', () => {
-    it('withdraws Reject and offers a same-key Check again', async () => {
-        const server = idempotentServer();
-        let dock;
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-                actionClient: server.client,
-                oncontroller: (c) => {
-                    dock = c;
-                },
-            },
-        });
-        await dock?.previewAction(proposal());
-        server.mode = 'commit-then-lose-response';
-        await userEvent.click(await screen.findByRole('button', { name: 'Confirm' }));
-        const check = await screen.findByRole('button', { name: 'Check again' });
-        expect(screen.getByRole('status')).toHaveTextContent(/couldn't confirm whether this change was applied/);
-        expect(screen.queryByRole('button', { name: 'Reject' })).toBeNull();
-        expect(screen.queryByRole('button', { name: 'Confirm' })).toBeNull();
-        server.mode = 'commit';
-        await userEvent.click(check);
-        await vi.waitFor(() => expect(screen.queryByRole('button', { name: 'Check again' })).toBeNull());
-        expect(dock?.actions.get(REQUEST_ID)?.status).toBe('applied');
-        expect(server.commits).toBe(1);
-    });
-});