@happyvertical/smrt-chat 0.51.10 → 0.51.15

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

@@ -13,9 +13,10 @@
  */
 import { createDataSurfaceRegistry, } from '@happyvertical/smrt-ui/data-surface';
 import { expectNoA11yViolations, render, screen, userEvent, } from '@happyvertical/smrt-vitest/svelte';
+import { createRawSnippet } from 'svelte';
 import { describe, expect, it, vi } from 'vitest';
 import AssistantDock from '../AssistantDock.svelte';
-import { createInMemoryAssistantTransport } from '../assistant-transport.js';
+import { createInMemoryAssistantTransport, } from '../assistant-transport.js';
 const identity = {
     surfaceId: 'orders',
     kind: 'table',
@@ -392,4 +393,123 @@ describe('AssistantDock (mounted component)', () => {
         const attachmentText = await screen.findByText('evil.txt');
         expect(attachmentText.closest('a')).toBeNull();
     });
+    // #3000: in a narrow container the thread list collapses behind a
+    // "Conversations" disclosure (the `@container` rule decides visibility;
+    // jsdom has no layout, so this pins the state + ARIA contract the CSS
+    // keys off). Widths are measured in a real browser, see the PR.
+    it('exposes a labelled Conversations disclosure that controls the thread list and closes when a conversation starts (#3000)', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        const { container } = render(AssistantDock, {
+            props: { transport, registry },
+        });
+        const toggle = screen.getByRole('button', { name: 'Conversations' });
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        const controlsId = toggle.getAttribute('aria-controls');
+        expect(controlsId).toBeTruthy();
+        const region = container.querySelector(`#${CSS.escape(controlsId ?? '')}`);
+        expect(region).not.toBeNull();
+        expect(region?.querySelector('nav[aria-label="Assistant conversations"]')).not.toBeNull();
+        const layout = container.querySelector('.assistant-dock-layout');
+        expect(layout).not.toHaveAttribute('data-threads-open');
+        await userEvent.click(toggle);
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        expect(layout).toHaveAttribute('data-threads-open');
+        toggle.focus();
+        await userEvent.keyboard('{Enter}');
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        await userEvent.keyboard(' ');
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        // Starting a conversation from the open list hands the width back.
+        await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        expect(layout).not.toHaveAttribute('data-threads-open');
+        // The activated button is now inside a hidden region; focus returns to
+        // the toggle instead of falling back to <body>.
+        await vi.waitFor(() => expect(document.activeElement).toBe(toggle));
+        await expectNoA11yViolations(container);
+    });
+    it('closes the narrow list and returns focus to the toggle when an existing thread is selected (#3000)', async () => {
+        const registry = createDataSurfaceRegistry();
+        const transport = createInMemoryAssistantTransport();
+        await transport.createThread('Existing chat');
+        render(AssistantDock, { props: { transport, registry } });
+        const toggle = screen.getByRole('button', { name: 'Conversations' });
+        await userEvent.click(toggle);
+        expect(toggle).toHaveAttribute('aria-expanded', 'true');
+        await userEvent.click(await screen.findByRole('button', { name: /Existing chat/ }));
+        expect(toggle).toHaveAttribute('aria-expanded', 'false');
+        await vi.waitFor(() => expect(document.activeElement).toBe(toggle));
+    });
+    // #2988: a host renders a message's own toolCallData through the
+    // `toolCall` snippet; without one the dock never renders the payload.
+    describe('toolCall snippet (#2988)', () => {
+        const hostile = '<img src=x onerror="window.__pwned=1">';
+        function transportWithToolCall() {
+            return createInMemoryAssistantTransport({
+                respond: (threadId, userMessage) => ({
+                    id: `assistant-${userMessage.id}`,
+                    threadId,
+                    content: userMessage.content === 'plain' ? 'no tool' : 'with tool',
+                    role: 'assistant',
+                    createdAt: new Date(),
+                    toolCallData: userMessage.content === 'plain'
+                        ? undefined
+                        : { kind: 'imageEditCandidate', label: hostile },
+                }),
+            });
+        }
+        async function sendThroughDock(text) {
+            const textarea = await screen.findByLabelText('Message');
+            await userEvent.type(textarea, text);
+            await userEvent.click(screen.getByRole('button', { name: 'Send' }));
+        }
+        it('renders the host snippet inside the bubble only for messages with toolCallData', async () => {
+            const seen = [];
+            const toolCall = createRawSnippet((message) => ({
+                render: () => '<span class="host-tool-call"></span>',
+                setup(node) {
+                    const m = message();
+                    seen.push(m);
+                    const data = m.toolCallData;
+                    node.textContent = `${data.kind}: ${data.label}`;
+                },
+            }));
+            const { container } = render(AssistantDock, {
+                props: {
+                    transport: transportWithToolCall(),
+                    registry: createDataSurfaceRegistry(),
+                    toolCall,
+                },
+            });
+            await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+            await sendThroughDock('plain');
+            expect(await screen.findByText('no tool')).toBeInTheDocument();
+            await sendThroughDock('tool');
+            expect(await screen.findByText('with tool')).toBeInTheDocument();
+            const regions = container.querySelectorAll('.assistant-dock-tool-call');
+            expect(regions).toHaveLength(1);
+            expect(regions[0].textContent).toBe(`imageEditCandidate: ${hostile}`);
+            // Rendered as text, never parsed as markup.
+            expect(container.querySelector('img')).toBeNull();
+            expect(regions[0]
+                .closest('li')
+                ?.querySelector('.assistant-dock-message-content')?.textContent).toBe('with tool');
+            expect(seen.every((m) => m.toolCallData != null)).toBe(true);
+        });
+        it('renders no tool-call region and never the raw payload without a snippet', async () => {
+            const { container } = render(AssistantDock, {
+                props: {
+                    transport: transportWithToolCall(),
+                    registry: createDataSurfaceRegistry(),
+                },
+            });
+            await userEvent.click(screen.getByRole('button', { name: /New conversation/i }));
+            await sendThroughDock('tool');
+            expect(await screen.findByText('with tool')).toBeInTheDocument();
+            expect(container.querySelector('.assistant-dock-tool-call')).toBeNull();
+            expect(container.innerHTML).not.toContain('imageEditCandidate');
+            expect(container.querySelector('img')).toBeNull();
+        });
+    });
 });

package/dist/svelte/components/assistant/__tests__/assistant-dock-action-outcome.test.js

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