@happyvertical/smrt-chat 0.53.1 → 0.53.2

package/dist/svelte/components/assistant/__tests__/assistant-dock-draft-settled.test.js

@@ -1,448 +0,0 @@
-// @vitest-environment jsdom
-/**
- * #2991: a host can seed the composer draft (`initialDraft`,
- * `controller.setDraft`) without sending it, and pass a composer
- * `placeholder` through the dock. Also the `onActionSettled` /
- * `onactionsettled` outcome callback for applied, rejected, and unknown
- * action outcomes.
- */
-import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
-import { render, screen, userEvent } from '@happyvertical/smrt-vitest/svelte';
-import { flushSync } from 'svelte';
-import { describe, expect, it, vi } from 'vitest';
-import AssistantComposer from '../AssistantComposer.svelte';
-import AssistantDock from '../AssistantDock.svelte';
-import { createInMemoryAssistantTransport } from '../assistant-transport.js';
-import { createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
-const identity = {
-    surfaceId: 'assets',
-    kind: 'table',
-    subject: { type: 'tenant', id: 'tenant-a' },
-};
-function registryWithSurface() {
-    const registry = createDataSurfaceRegistry();
-    const descriptor = {
-        version: 1,
-        identity,
-        schemaVersion: 1,
-        label: 'Assets',
-        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;
-}
-function proposal(requestId = 'req-1') {
-    return {
-        version: 1,
-        requestId,
-        identity,
-        actionId: 'approve',
-        phase: 'preview',
-        selection: { scope: 'explicit-ids', rowIds: ['row-1'] },
-    };
-}
-function result(request, phase, ok, extra = {}) {
-    return {
-        version: 1,
-        requestId: request.requestId,
-        identity: request.identity,
-        actionId: request.actionId,
-        phase,
-        ok,
-        ...extra,
-    };
-}
-function client(apply) {
-    return {
-        preview: async (request) => result(request, 'preview', true, { confirmationToken: 'tok' }),
-        apply,
-    };
-}
-function textarea() {
-    return screen.getByLabelText('Message');
-}
-describe('AssistantComposer value (#2991)', () => {
-    it('renders a seeded value without sending it', () => {
-        const onsend = vi.fn();
-        render(AssistantComposer, {
-            props: { onsend, onupload: vi.fn(), value: 'Remove the background' },
-        });
-        expect(textarea()).toHaveValue('Remove the background');
-        expect(onsend).not.toHaveBeenCalled();
-    });
-    it('sends the edited seed only when the user sends', async () => {
-        const onsend = vi.fn().mockResolvedValue(undefined);
-        render(AssistantComposer, {
-            props: { onsend, onupload: vi.fn(), value: 'Remove the background' },
-        });
-        await userEvent.type(textarea(), ' please');
-        expect(onsend).not.toHaveBeenCalled();
-        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
-        expect(onsend).toHaveBeenCalledWith('Remove the background please', []);
-        expect(textarea()).toHaveValue('');
-    });
-});
-describe('AssistantComposer in-flight edits (#2991)', () => {
-    it('keeps text typed while the send was in flight', async () => {
-        let release;
-        const onsend = vi.fn(() => new Promise((resolve) => {
-            release = resolve;
-        }));
-        render(AssistantComposer, {
-            props: { onsend, onupload: vi.fn(), value: 'first' },
-        });
-        await userEvent.click(screen.getByRole('button', { name: 'Send' }));
-        await userEvent.type(textarea(), ' and more');
-        release();
-        await vi.waitFor(() => expect(onsend).toHaveBeenCalledTimes(1));
-        await new Promise((resolve) => setTimeout(resolve, 0));
-        expect(textarea()).toHaveValue('first and more');
-    });
-});
-describe('controller draft (#2991)', () => {
-    it('starts from initialDraft and setDraft replaces it without sending', async () => {
-        const transport = createInMemoryAssistantTransport();
-        const sendMessage = vi.spyOn(transport, 'sendMessage');
-        const controller = createAssistantDockController({
-            transport,
-            registry: registryWithSurface(),
-            initialDraft: 'first',
-        });
-        expect(controller.draft).toBe('first');
-        controller.setDraft('second');
-        expect(controller.draft).toBe('second');
-        expect(sendMessage).not.toHaveBeenCalled();
-        controller.dispose();
-    });
-    it('keeps the draft across a registry or transport swap', () => {
-        let registry = registryWithSurface();
-        let transport = createInMemoryAssistantTransport();
-        const controller = createAssistantDockController({
-            get transport() {
-                return transport;
-            },
-            get registry() {
-                return registry;
-            },
-            initialDraft: 'unsent text',
-        });
-        registry = registryWithSurface();
-        controller.syncRegistry();
-        expect(controller.draft).toBe('unsent text');
-        transport = createInMemoryAssistantTransport();
-        controller.syncTransport();
-        expect(controller.draft).toBe('unsent text');
-        controller.dispose();
-    });
-    it('clears the draft after a headless send of that draft', async () => {
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-        });
-        const thread = await controller.createThread('t');
-        await controller.openThread(thread.id);
-        controller.setDraft('hello');
-        await controller.send('hello');
-        expect(controller.draft).toBe('');
-        controller.dispose();
-    });
-    it('keeps a draft changed while the send was in flight', async () => {
-        const transport = createInMemoryAssistantTransport();
-        const controller = createAssistantDockController({
-            transport,
-            registry: registryWithSurface(),
-        });
-        const thread = await controller.createThread('t');
-        await controller.openThread(thread.id);
-        controller.setDraft('hello');
-        const sending = controller.send('hello');
-        controller.setDraft('next message');
-        await sending;
-        expect(controller.draft).toBe('next message');
-        controller.dispose();
-    });
-    it('does not clear a kept draft when a send completes after a swap', async () => {
-        let transport = createInMemoryAssistantTransport();
-        const controller = createAssistantDockController({
-            get transport() {
-                return transport;
-            },
-            registry: registryWithSurface(),
-        });
-        const thread = await controller.createThread('t');
-        await controller.openThread(thread.id);
-        controller.setDraft('hello');
-        const sending = controller.send('hello');
-        transport = createInMemoryAssistantTransport();
-        controller.syncTransport();
-        await sending.catch(() => undefined);
-        expect(controller.draft).toBe('hello');
-        controller.dispose();
-    });
-    it('defaults to an empty draft', () => {
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-        });
-        expect(controller.draft).toBe('');
-        controller.dispose();
-    });
-});
-describe('AssistantDock draft seeding and placeholder (#2991)', () => {
-    it('renders initialDraft in the composer and never sends it', async () => {
-        const transport = createInMemoryAssistantTransport();
-        const sendMessage = vi.spyOn(transport, 'sendMessage');
-        render(AssistantDock, {
-            props: {
-                transport,
-                registry: registryWithSurface(),
-                initialDraft: 'Remove the background from this photo',
-            },
-        });
-        expect(textarea()).toHaveValue('Remove the background from this photo');
-        await new Promise((resolve) => setTimeout(resolve, 20));
-        expect(sendMessage).not.toHaveBeenCalled();
-    });
-    it('lets the host seed the draft through controller.setDraft', async () => {
-        let hostController;
-        const transport = createInMemoryAssistantTransport();
-        const sendMessage = vi.spyOn(transport, 'sendMessage');
-        render(AssistantDock, {
-            props: {
-                transport,
-                registry: registryWithSurface(),
-                oncontroller: (c) => {
-                    hostController = c;
-                },
-            },
-        });
-        expect(textarea()).toHaveValue('');
-        hostController?.setDraft('Describe the edit');
-        flushSync();
-        expect(textarea()).toHaveValue('Describe the edit');
-        expect(sendMessage).not.toHaveBeenCalled();
-    });
-    it('reflects typed text back into controller.draft', async () => {
-        let hostController;
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-                initialDraft: 'seed',
-                oncontroller: (c) => {
-                    hostController = c;
-                },
-            },
-        });
-        // The composer is disabled until a thread is open; open one first.
-        const thread = await hostController?.createThread('t');
-        if (thread)
-            await hostController?.openThread(thread.id);
-        flushSync();
-        await userEvent.type(textarea(), ' more');
-        expect(hostController?.draft).toBe('seed more');
-    });
-    it('forwards composerPlaceholder to the composer', () => {
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-                composerPlaceholder: 'Describe the image edit to generate…',
-            },
-        });
-        expect(textarea()).toHaveAttribute('placeholder', 'Describe the image edit to generate…');
-    });
-    it('keeps the composer default placeholder when none is passed', () => {
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-            },
-        });
-        expect(textarea()).toHaveAttribute('placeholder', 'Ask the assistant…');
-    });
-});
-describe('controller onActionSettled', () => {
-    function settledController(apply, onActionSettled) {
-        return createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: client(apply),
-            onActionSettled,
-        });
-    }
-    it('reports an accepted apply as applied with the server result', async () => {
-        const onActionSettled = vi.fn();
-        const controller = settledController(async (request) => result(request, 'apply', true, { details: { assetId: 'srv-1' } }), onActionSettled);
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        expect(onActionSettled).toHaveBeenCalledTimes(1);
-        const [request, outcome] = onActionSettled.mock.calls[0];
-        expect(request.phase).toBe('apply');
-        expect(outcome.status).toBe('applied');
-        expect(outcome.result.details).toEqual({ assetId: 'srv-1' });
-        controller.dispose();
-    });
-    it('reports a server refusal as rejected by the server', async () => {
-        const onActionSettled = vi.fn();
-        const controller = settledController(async (request) => result(request, 'apply', false, { reason: 'stale_revision' }), onActionSettled);
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        expect(onActionSettled).toHaveBeenCalledTimes(1);
-        const outcome = onActionSettled.mock.calls[0][1];
-        expect(outcome).toMatchObject({ status: 'rejected', by: 'server' });
-        expect(outcome.result.reason).toBe('stale_revision');
-        controller.dispose();
-    });
-    it('reports a user reject as rejected by the user', async () => {
-        const onActionSettled = vi.fn();
-        const controller = settledController(async (request) => result(request, 'apply', true), onActionSettled);
-        await controller.previewAction(proposal());
-        controller.rejectAction('req-1');
-        expect(controller.actions.has('req-1')).toBe(false);
-        expect(onActionSettled).toHaveBeenCalledTimes(1);
-        const [request, outcome] = onActionSettled.mock.calls[0];
-        expect(request.requestId).toBe('req-1');
-        expect(outcome).toEqual({ status: 'rejected', by: 'user' });
-        controller.dispose();
-    });
-    it('reports a thrown apply as unknown, then the later decision', async () => {
-        const onActionSettled = vi.fn();
-        let mode = 'throw';
-        const controller = settledController(async (request) => {
-            if (mode === 'throw')
-                throw new Error('network down');
-            return result(request, 'apply', true);
-        }, onActionSettled);
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        expect(onActionSettled).toHaveBeenCalledTimes(1);
-        expect(onActionSettled.mock.calls[0][1]).toEqual({
-            status: 'unknown',
-            error: 'network down',
-        });
-        mode = 'ok';
-        await controller.applyAction('req-1');
-        expect(onActionSettled).toHaveBeenCalledTimes(2);
-        expect(onActionSettled.mock.calls[1][1].status).toBe('applied');
-        controller.dispose();
-    });
-    it('reports an unknown-outcome reason as unknown with the result', async () => {
-        const onActionSettled = vi.fn();
-        const controller = settledController(async (request) => result(request, 'apply', false, { reason: 'idempotency_in_progress' }), onActionSettled);
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        const outcome = onActionSettled.mock.calls[0][1];
-        expect(outcome.status).toBe('unknown');
-        expect(outcome.result.reason).toBe('idempotency_in_progress');
-        controller.dispose();
-    });
-    it('does not report a refused reject while the outcome is unknown', async () => {
-        const onActionSettled = vi.fn();
-        const controller = settledController(async () => {
-            throw new Error('timeout');
-        }, onActionSettled);
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        onActionSettled.mockClear();
-        controller.rejectAction('req-1');
-        expect(controller.actions.has('req-1')).toBe(true);
-        expect(onActionSettled).not.toHaveBeenCalled();
-        controller.dispose();
-    });
-    it('does not report an apply that lands after a context swap', async () => {
-        const onActionSettled = vi.fn();
-        let release;
-        let registry = registryWithSurface();
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            get registry() {
-                return registry;
-            },
-            actionClient: client(async (request) => {
-                await new Promise((resolve) => {
-                    release = resolve;
-                });
-                return result(request, 'apply', true);
-            }),
-            onActionSettled,
-        });
-        await controller.previewAction(proposal());
-        const applying = controller.applyAction('req-1');
-        registry = registryWithSurface();
-        controller.syncRegistry();
-        release();
-        await applying;
-        expect(onActionSettled).not.toHaveBeenCalled();
-        controller.dispose();
-    });
-    it('keeps action state when the host callback throws', async () => {
-        const onActionSettled = vi.fn(() => {
-            throw new Error('host bug');
-        });
-        const controller = settledController(async (request) => result(request, 'apply', true), onActionSettled);
-        await controller.previewAction(proposal());
-        await expect(controller.applyAction('req-1')).resolves.toBeUndefined();
-        expect(controller.actions.get('req-1')?.status).toBe('applied');
-        await controller.previewAction(proposal('req-2'));
-        expect(() => controller.rejectAction('req-2')).not.toThrow();
-        expect(controller.actions.has('req-2')).toBe(false);
-        controller.dispose();
-    });
-    it('still calls onActionApplied alongside onActionSettled', async () => {
-        const onActionApplied = vi.fn();
-        const onActionSettled = vi.fn();
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: client(async (request) => result(request, 'apply', true)),
-            onActionApplied,
-            onActionSettled,
-        });
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-1');
-        expect(onActionApplied).toHaveBeenCalledTimes(1);
-        expect(onActionSettled).toHaveBeenCalledTimes(1);
-        controller.dispose();
-    });
-});
-describe('AssistantDock onactionsettled', () => {
-    it('reports a Reject click to the host', async () => {
-        let hostController;
-        const onactionsettled = vi.fn();
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-                actionClient: client(async (request) => result(request, 'apply', true)),
-                oncontroller: (c) => {
-                    hostController = c;
-                },
-                onactionsettled,
-            },
-        });
-        await hostController?.previewAction(proposal());
-        await userEvent.click(await screen.findByRole('button', { name: 'Reject' }));
-        await vi.waitFor(() => expect(onactionsettled).toHaveBeenCalledTimes(1));
-        expect(onactionsettled.mock.calls[0][1]).toEqual({
-            status: 'rejected',
-            by: 'user',
-        });
-    });
-});

package/dist/svelte/components/assistant/__tests__/assistant-dock-host-actions.test.js

@@ -1,185 +0,0 @@
-// @vitest-environment jsdom
-/**
- * #2989: a host can propose an action into the dock and observe an applied
- * outcome — controller `onActionApplied`, and AssistantDock's
- * `oncontroller` / `onactionapplied` props.
- */
-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 { createAssistantDockController, } from '../create-assistant-dock-controller.svelte.js';
-const identity = {
-    surfaceId: 'assets',
-    kind: 'table',
-    subject: { type: 'tenant', id: 'tenant-a' },
-};
-function registryWithSurface() {
-    const registry = createDataSurfaceRegistry();
-    const descriptor = {
-        version: 1,
-        identity,
-        schemaVersion: 1,
-        label: 'Assets',
-        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;
-}
-function proposal(requestId = 'req-approve') {
-    return {
-        version: 1,
-        requestId,
-        identity,
-        actionId: 'approve',
-        phase: 'preview',
-        selection: { scope: 'explicit-ids', rowIds: ['row-sent'] },
-    };
-}
-function result(request, phase, ok, extra = {}) {
-    return {
-        version: 1,
-        requestId: request.requestId,
-        identity: request.identity,
-        actionId: request.actionId,
-        phase,
-        ok,
-        ...extra,
-    };
-}
-function client(apply) {
-    return {
-        preview: async (request) => result(request, 'preview', true, { confirmationToken: 'tok' }),
-        apply,
-    };
-}
-describe('controller onActionApplied (#2989)', () => {
-    it('fires once with the server result for an accepted apply', async () => {
-        const onActionApplied = vi.fn();
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: client(async (request) => result(request, 'apply', true, {
-                details: { approvedAssetId: 'asset-from-server' },
-            })),
-            onActionApplied,
-        });
-        await controller.previewAction(proposal());
-        await controller.applyAction('req-approve');
-        expect(controller.actions.get('req-approve')?.status).toBe('applied');
-        expect(onActionApplied).toHaveBeenCalledTimes(1);
-        const [request, applied] = onActionApplied.mock.calls[0];
-        expect(request.phase).toBe('apply');
-        expect(request.requestId).toBe('req-approve');
-        expect(applied.details).toEqual({ approvedAssetId: 'asset-from-server' });
-        controller.dispose();
-    });
-    it('does not fire for a refusal or a thrown apply', async () => {
-        const onActionApplied = vi.fn();
-        let mode = 'refuse';
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: client(async (request) => {
-                if (mode === 'throw')
-                    throw new Error('network down');
-                return result(request, 'apply', false, { reason: 'denied' });
-            }),
-            onActionApplied,
-        });
-        await controller.previewAction(proposal('req-a'));
-        await controller.applyAction('req-a');
-        mode = 'throw';
-        await controller.previewAction(proposal('req-b'));
-        await controller.applyAction('req-b');
-        expect(onActionApplied).not.toHaveBeenCalled();
-        controller.dispose();
-    });
-    it('keeps the applied state when the host callback throws', async () => {
-        const onActionApplied = vi.fn(() => {
-            throw new Error('host bug');
-        });
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            registry: registryWithSurface(),
-            actionClient: client(async (request) => result(request, 'apply', true)),
-            onActionApplied,
-        });
-        await controller.previewAction(proposal());
-        await expect(controller.applyAction('req-approve')).resolves.toBeUndefined();
-        expect(onActionApplied).toHaveBeenCalledTimes(1);
-        expect(controller.actions.get('req-approve')?.status).toBe('applied');
-        controller.dispose();
-    });
-    it('does not fire for an apply that lands after a context swap', async () => {
-        const onActionApplied = vi.fn();
-        let release;
-        let registry = registryWithSurface();
-        const controller = createAssistantDockController({
-            transport: createInMemoryAssistantTransport(),
-            get registry() {
-                return registry;
-            },
-            actionClient: client(async (request) => {
-                await new Promise((resolve) => {
-                    release = resolve;
-                });
-                return result(request, 'apply', true);
-            }),
-            onActionApplied,
-        });
-        await controller.previewAction(proposal());
-        const applying = controller.applyAction('req-approve');
-        registry = registryWithSurface();
-        controller.syncRegistry();
-        release();
-        await applying;
-        expect(onActionApplied).not.toHaveBeenCalled();
-        controller.dispose();
-    });
-});
-describe('AssistantDock oncontroller / onactionapplied (#2989)', () => {
-    it('lets a host propose an action and observe the applied outcome', async () => {
-        let hostController;
-        const onactionapplied = vi.fn();
-        const oncontroller = vi.fn((c) => {
-            hostController = c;
-        });
-        render(AssistantDock, {
-            props: {
-                transport: createInMemoryAssistantTransport(),
-                registry: registryWithSurface(),
-                actionClient: client(async (request) => result(request, 'apply', true, {
-                    details: { approvedAssetId: 'asset-from-server' },
-                })),
-                oncontroller,
-                onactionapplied,
-            },
-        });
-        expect(oncontroller).toHaveBeenCalledTimes(1);
-        expect(hostController).toBeDefined();
-        await hostController?.previewAction(proposal());
-        await userEvent.click(await screen.findByRole('button', { name: 'Confirm' }));
-        await vi.waitFor(() => expect(onactionapplied).toHaveBeenCalledTimes(1));
-        expect(onactionapplied.mock.calls[0][1].details).toEqual({
-            approvedAssetId: 'asset-from-server',
-        });
-    });
-});