@classic-homes/agent-chat 0.11.0 → 0.13.0

package/dist/components/live-fixes.svelte.test.js

@@ -1,127 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen, waitFor } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import TwoSheets from '../../test-fixtures/TwoSheets.svelte';
-import { releaseStuckBodyLock } from '../body-lock.js';
-import { parseMarkdown } from '../markdown.js';
-import { ChatSession } from '../session.svelte.js';
-import AgentChat from './AgentChat.svelte';
-import ConversationSidebar from './ConversationSidebar.svelte';
-import Markdown from './Markdown.svelte';
-const wait = (ms) => new Promise((r) => setTimeout(r, ms));
-afterEach(() => {
-    cleanup();
-    document.body.removeAttribute('style');
-});
-/** A client whose streamChat replays `events` (all in one tick) and reports done. */
-function fakeClient(events) {
-    return {
-        fileUrl: (id) => `#${id}`,
-        uploadFile: vi.fn(),
-        cancel: vi.fn(),
-        getConversation: vi.fn(),
-        resumeTurn: vi.fn(),
-        streamChat: vi.fn(async (req, opts) => {
-            events(req.requestId).forEach((e, seq) => opts.onEvent({ requestId: req.requestId, seq, ...e }));
-            return { kind: 'done' };
-        }),
-    };
-}
-const scope = { agent: 'classic-agent', runId: 'run-1' };
-const turn = (requestId) => [
-    { type: 'start', conversationId: 'c-1', mode: 'live' },
-    { type: 'delta', text: 'Here it is.' },
-    {
-        type: 'artifact',
-        ...scope,
-        artifactId: 'a1',
-        op: 'open',
-        mediaType: 'text/markdown',
-        title: 'Memo',
-    },
-    { type: 'artifact', ...scope, artifactId: 'a1', op: 'delta', text: '# Memo' },
-    { type: 'artifact', ...scope, artifactId: 'a1', op: 'close' },
-    { type: 'done', finishReason: 'stop' },
-].map((e) => ({ ...e, requestId }));
-describe('body lock guard', () => {
-    it('clears the lock the bits-ui race leaves behind once no modal is open', async () => {
-        // Reproduces the race: A closes and B opens in the same tick, then B closes.
-        const { rerender } = render(TwoSheets, { props: { a: true, b: false } });
-        await wait(100);
-        await rerender({ a: false, b: false });
-        await wait(0);
-        await rerender({ a: false, b: true });
-        await wait(300);
-        await rerender({ a: false, b: false });
-        await wait(600);
-        expect(document.body.style.pointerEvents).toBe('none');
-        releaseStuckBodyLock(0);
-        await wait(10);
-        expect(document.body.style.pointerEvents).toBe('');
-        expect(document.body.style.overflow).toBe('');
-    });
-    it('leaves the lock alone while a modal is open', async () => {
-        render(TwoSheets, { props: { a: true } });
-        await wait(300);
-        releaseStuckBodyLock(0);
-        await wait(10);
-        expect(document.body.style.pointerEvents).toBe('none');
-    });
-});
-describe('ChatSession onTurnEnd', () => {
-    it('reports the finished turn with its conversation and status', async () => {
-        const onTurnEnd = vi.fn();
-        const client = fakeClient(turn);
-        const session = new ChatSession({ client: client, onTurnEnd });
-        await session.send('hi');
-        expect(onTurnEnd).toHaveBeenCalledOnce();
-        expect(onTurnEnd.mock.calls[0][0]).toMatchObject({ conversationId: 'c-1', status: 'done' });
-    });
-});
-describe('AgentChat artifacts', () => {
-    it('opens an artifact that starts and finishes within one tick', async () => {
-        const user = userEvent.setup();
-        const onturnend = vi.fn();
-        render(AgentChat, {
-            props: { client: fakeClient(turn), sandboxOrigin: 'https://frame.test', onturnend },
-        });
-        await user.type(screen.getByRole('textbox', { name: 'Message' }), 'memo{Enter}');
-        // jsdom has no wide viewport, so the artifact opens in the sheet.
-        expect(await screen.findByRole('dialog', { name: 'Memo' })).toBeTruthy();
-        await waitFor(() => expect(onturnend).toHaveBeenCalledOnce());
-    });
-});
-describe('rename dialog', () => {
-    it('starts in the title field with the title selected', async () => {
-        const user = userEvent.setup();
-        const now = new Date().toISOString();
-        render(ConversationSidebar, {
-            props: {
-                conversations: [
-                    {
-                        conversationId: 'c1',
-                        agent: 'classic-agent',
-                        title: 'Lot 12',
-                        createdAt: now,
-                        updatedAt: now,
-                    },
-                ],
-                onrename: vi.fn(),
-            },
-        });
-        await user.click(screen.getByRole('button', { name: 'Options for Lot 12' }));
-        await user.click(await screen.findByRole('menuitem', { name: /Rename/ }));
-        const field = await screen.findByRole('textbox', { name: 'Conversation title' });
-        await waitFor(() => expect(document.activeElement).toBe(field));
-        const input = field;
-        expect([input.selectionStart, input.selectionEnd]).toEqual([0, 'Lot 12'.length]);
-    });
-});
-describe('Markdown tables', () => {
-    it('keep words whole so wide tables scroll instead of breaking numbers', () => {
-        const { container } = render(Markdown, {
-            props: { html: parseMarkdown('| a | b |\n| - | - |\n| $1,075,000 | x |') },
-        });
-        expect(container.firstElementChild.className).toContain('[&_table]:[overflow-wrap:normal]');
-    });
-});

package/dist/components/markdown-prose.svelte.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=markdown-prose.svelte.test.d.ts.map

package/dist/components/markdown-prose.svelte.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown-prose.svelte.test.d.ts","sourceRoot":"","sources":["../../src/lib/components/markdown-prose.svelte.test.ts"],"names":[],"mappings":""}

package/dist/components/markdown-prose.svelte.test.js

@@ -1,26 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { cleanup, render } from '@testing-library/svelte';
-import { parseMarkdown } from '../markdown.js';
-import { errorTitle } from '../reducer.js';
-import Markdown from './Markdown.svelte';
-afterEach(cleanup);
-describe('Markdown', () => {
-    // The Classic App's cascade-layers polyfill outranks plain component CSS, so the prose rules
-    // must be utilities on the container (classic-agent visual check, 2026-11-03).
-    it('styles prose with utility classes, not a stylesheet', () => {
-        const { container } = render(Markdown, {
-            props: { html: parseMarkdown('- one\n- two'), class: 'text-sm' },
-        });
-        const root = container.firstElementChild;
-        expect(root.className).toContain('[&_ul]:list-disc');
-        expect(root.className).toContain('[&_td]:border');
-        expect(root.className).toContain('text-sm');
-        expect(root.querySelectorAll('li')).toHaveLength(2);
-        expect(document.querySelectorAll('style')).toHaveLength(0);
-    });
-});
-describe('errorTitle', () => {
-    it('falls back for a code this client does not know', () => {
-        expect(errorTitle('upstream')).toBe('Something went wrong');
-    });
-});

package/dist/components/messages.svelte.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=messages.svelte.test.d.ts.map

package/dist/components/messages.svelte.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"messages.svelte.test.d.ts","sourceRoot":"","sources":["../../src/lib/components/messages.svelte.test.ts"],"names":[],"mappings":""}

package/dist/components/messages.svelte.test.js

@@ -1,215 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import { parseMarkdown } from '../markdown.js';
-import { daySeparators, describeProposal, formatBytes, formatDay } from '../message-format.js';
-import { newAssistantMessage, newUserMessage } from '../reducer.js';
-import AssistantMessageView from './AssistantMessage.svelte';
-import Markdown from './Markdown.svelte';
-import MessageList from './MessageList.svelte';
-import UserMessageView from './UserMessage.svelte';
-afterEach(() => cleanup());
-const base = { sandboxOrigin: 'https://frame.test', fileUrl: (id) => `/files/${id}` };
-const assistant = (patch = {}) => ({
-    ...newAssistantMessage('r1', Date.UTC(2026, 10, 3, 15, 0)),
-    status: 'done',
-    ...patch,
-});
-const DAY = 86_400_000;
-describe('message formatting', () => {
-    it('formats sizes and relative days', () => {
-        expect(formatBytes(900)).toBe('900 B');
-        expect(formatBytes(2048)).toBe('2 KB');
-        expect(formatBytes(3 * 1048576)).toBe('3.0 MB');
-        const now = new Date(2026, 10, 3, 12).getTime();
-        expect(formatDay(now - 60_000, now)).toBe('Today');
-        expect(formatDay(now - DAY, now)).toBe('Yesterday');
-        expect(formatDay(now - 5 * DAY, now)).not.toMatch(/Today|Yesterday/);
-    });
-    it('marks the first message of each day', () => {
-        const t = new Date(2026, 10, 1, 10).getTime();
-        expect([...daySeparators([{ createdAt: t }, { createdAt: t + 60_000 }])]).toEqual([0]);
-        expect([...daySeparators([{ createdAt: t }, { createdAt: t + DAY }])]).toEqual([0, 1]);
-    });
-    it('describes proposals without applying them', () => {
-        const op = {
-            kind: 'excel.writeRange',
-            operationId: '00000000-0000-4000-8000-000000000001',
-            documentId: 'doc-1',
-            summary: 'Fill totals',
-            target: { sheet: 'Budget', address: 'B2:B4' },
-            write: { type: 'values', values: [[1], [2], [3]] },
-            precondition: { formulas: [[''], [''], ['']] },
-        };
-        expect(describeProposal(op)).toEqual({
-            action: 'Write values',
-            host: 'Excel',
-            target: 'Budget!B2:B4',
-        });
-    });
-});
-describe('markdown output', () => {
-    it('wraps tables in a scrolling container and never trusts a literal div', () => {
-        const html = parseMarkdown('| A | B |\n|---|---|\n| 1 | 2 |\n\n<div class="agent-x">hi</div>');
-        expect(html).toMatch(/<div class="agent-table-wrap"><table class="agent-table">/);
-        expect(html).toContain('&lt;div');
-        expect(html.match(/<div/g)).toHaveLength(1);
-    });
-    it('marks external links', () => {
-        expect(parseMarkdown('[docs](https://example.com/)')).toContain('class="agent-external-link"');
-    });
-});
-describe('Markdown code blocks', () => {
-    it('adds a language header whose button copies the code', async () => {
-        const writeText = vi.fn().mockResolvedValue(undefined);
-        Object.defineProperty(navigator, 'clipboard', { value: { writeText }, configurable: true });
-        render(Markdown, { props: { html: parseMarkdown('```ts\nconst a = 1;\n```') } });
-        const button = await screen.findByRole('button', { name: 'Copy ts code' });
-        expect(button.closest('.agent-codeblock')?.textContent).toContain('ts');
-        await fireEvent.click(button);
-        expect(writeText).toHaveBeenCalledWith('const a = 1;');
-        await waitFor(() => expect(button.textContent).toContain('Copied'));
-    });
-});
-describe('AssistantMessage', () => {
-    it('shows a retryable error with Try again', async () => {
-        const onretry = vi.fn();
-        render(AssistantMessageView, {
-            props: {
-                ...base,
-                last: true,
-                onretry,
-                message: assistant({
-                    status: 'error',
-                    error: { code: 'upstream_error', message: 'Model failed.', retryable: true },
-                }),
-            },
-        });
-        expect(screen.getByText(/The agent ran into a problem/)).toBeTruthy();
-        await userEvent.click(screen.getByRole('button', { name: /Try again/ }));
-        expect(onretry).toHaveBeenCalledOnce();
-    });
-    it('offers Continue on a cut-short or stopped last answer only', async () => {
-        const oncontinue = vi.fn();
-        const { rerender } = render(AssistantMessageView, {
-            props: {
-                ...base,
-                last: true,
-                oncontinue,
-                message: assistant({ status: 'incomplete', text: 'Partial' }),
-            },
-        });
-        expect(screen.getByText('The answer was cut short.')).toBeTruthy();
-        await userEvent.click(screen.getByRole('button', { name: 'Continue' }));
-        expect(oncontinue).toHaveBeenCalledOnce();
-        await rerender({
-            ...base,
-            last: true,
-            oncontinue,
-            message: assistant({ status: 'cancelled', text: 'Partial' }),
-        });
-        expect(screen.getByText('Stopped')).toBeTruthy();
-        expect(screen.getByRole('button', { name: 'Continue' })).toBeTruthy();
-        await rerender({
-            ...base,
-            last: false,
-            oncontinue,
-            message: assistant({ status: 'cancelled', text: 'Partial' }),
-        });
-        expect(screen.queryByRole('button', { name: 'Continue' })).toBeNull();
-        // Stopped before any text: nothing to continue (Regenerate asks again).
-        await rerender({
-            ...base,
-            last: true,
-            oncontinue,
-            message: assistant({ status: 'cancelled' }),
-        });
-        expect(screen.queryByRole('button', { name: 'Continue' })).toBeNull();
-    });
-    it('renders artifacts, proposals and a thinking state', async () => {
-        const onopenartifact = vi.fn();
-        const { rerender } = render(AssistantMessageView, {
-            props: { ...base, streaming: true, message: assistant({ status: 'streaming' }) },
-        });
-        expect(screen.getByRole('status').textContent).toContain('Thinking');
-        await rerender({
-            ...base,
-            onopenartifact,
-            message: assistant({
-                artifacts: [
-                    { artifactId: 'a1', mediaType: 'text/html', title: 'Plans', text: '', open: false },
-                    { artifactId: 'a2', mediaType: 'text/markdown', title: 'Memo', text: '', open: true },
-                ],
-                proposals: [
-                    {
-                        kind: 'word.replaceSelection',
-                        operationId: '00000000-0000-4000-8000-000000000002',
-                        documentId: 'doc-1',
-                        summary: 'Tighten the intro',
-                        target: { targetId: 't1', expectedText: 'Old' },
-                        text: 'New',
-                    },
-                ],
-            }),
-        });
-        expect(screen.queryByText('Thinking')).toBeNull();
-        await userEvent.click(screen.getByRole('button', { name: 'Open Plans' }));
-        expect(onopenartifact).toHaveBeenCalledWith('a1');
-        expect(screen.getByRole('button', { name: 'Memo (writing)' })).toBeTruthy();
-        expect(screen.getByText('Tighten the intro')).toBeTruthy();
-        expect(screen.getByText('Apply from the Word add-in.')).toBeTruthy();
-    });
-    it('has a copy action once the answer is done', () => {
-        render(AssistantMessageView, {
-            props: { ...base, message: assistant({ text: 'Hello there' }) },
-        });
-        expect(screen.getByRole('button', { name: 'Copy message' })).toBeTruthy();
-    });
-});
-describe('UserMessage', () => {
-    it('shows the text in a bubble with its attachments', () => {
-        const message = newUserMessage('r1', 'See attached', {
-            attachments: [
-                {
-                    fileId: 'f1',
-                    name: 'plan.pdf',
-                    mimeType: 'application/pdf',
-                    bytes: 2048,
-                    status: 'uploaded',
-                },
-            ],
-        });
-        render(UserMessageView, { props: { message } });
-        expect(screen.getByText('See attached')).toBeTruthy();
-        expect(screen.getByText('plan.pdf')).toBeTruthy();
-        expect(screen.getByText('2 KB')).toBeTruthy();
-    });
-});
-describe('MessageList', () => {
-    it('labels days only when the transcript spans more than one', () => {
-        const t = Date.now();
-        const one = [newUserMessage('r1', 'hi', { now: t }), assistant({ createdAt: t })];
-        const { rerender } = render(MessageList, {
-            props: { ...base, streaming: false, messages: one },
-        });
-        expect(screen.queryByRole('separator')).toBeNull();
-        const two = [newUserMessage('r0', 'old', { now: t - 3 * DAY }), ...one];
-        void rerender({ ...base, streaming: false, messages: two });
-        return waitFor(() => expect(screen.getAllByRole('separator').map((s) => s.textContent?.trim())).toContain('Today'));
-    });
-    it('offers a jump to the latest once the reader scrolls up', async () => {
-        render(MessageList, {
-            props: { ...base, streaming: false, messages: [newUserMessage('r1', 'hi'), assistant()] },
-        });
-        const log = screen.getByRole('log');
-        Object.defineProperty(log, 'scrollHeight', { value: 2000, configurable: true });
-        Object.defineProperty(log, 'clientHeight', { value: 500, configurable: true });
-        log.scrollTop = 100;
-        await fireEvent.scroll(log);
-        const jump = await screen.findByRole('button', { name: 'Jump to the latest message' });
-        log.scrollTo = vi.fn();
-        await userEvent.click(jump);
-        expect(log.scrollTo).toHaveBeenCalled();
-        expect(screen.queryByRole('button', { name: /latest/ })).toBeNull();
-    });
-});

package/dist/components/regenerate.svelte.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=regenerate.svelte.test.d.ts.map

package/dist/components/regenerate.svelte.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"regenerate.svelte.test.d.ts","sourceRoot":"","sources":["../../src/lib/components/regenerate.svelte.test.ts"],"names":[],"mappings":""}

package/dist/components/regenerate.svelte.test.js

@@ -1,108 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen, waitFor } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import { latestTurn, newAssistantMessage, newUserMessage } from '../reducer.js';
-import { ChatSession } from '../session.svelte.js';
-import AgentChat from './AgentChat.svelte';
-afterEach(() => cleanup());
-/** Answers each request with "Answer N" (N counts requests). */
-function fakeClient() {
-    let n = 0;
-    return {
-        fileUrl: (id) => `#${id}`,
-        uploadFile: vi.fn(),
-        cancel: vi.fn(),
-        getConversation: vi.fn(),
-        resumeTurn: vi.fn(),
-        streamChat: vi.fn(async (req, opts) => {
-            n += 1;
-            [
-                { type: 'start', conversationId: 'c-1', mode: 'live' },
-                { type: 'delta', text: `Answer ${n}` },
-                { type: 'done', finishReason: 'stop' },
-            ].forEach((e, seq) => opts.onEvent({ requestId: req.requestId, seq, ...e }));
-            return { kind: 'done' };
-        }),
-    };
-}
-describe('latestTurn', () => {
-    it('finds the finished latest turn only', () => {
-        const done = { ...newAssistantMessage('r2'), status: 'done' };
-        const messages = [
-            newUserMessage('r1', 'one'),
-            { ...newAssistantMessage('r1'), status: 'done' },
-            newUserMessage('r2', 'two'),
-            done,
-        ];
-        expect(latestTurn(messages, 'r2')?.user.text).toBe('two');
-        expect(latestTurn(messages, 'r2')?.rest).toHaveLength(2);
-        expect(latestTurn(messages, 'r1')).toBeUndefined();
-        expect(latestTurn([...messages.slice(0, 3), newAssistantMessage('r2')], 'r2')).toBeUndefined();
-    });
-});
-describe('ChatSession regenerate and edit', () => {
-    it('replaces the latest turn instead of adding one', async () => {
-        const client = fakeClient();
-        const session = new ChatSession({ client: client });
-        await session.send('first');
-        const firstId = client.streamChat.mock.calls[0][0].requestId;
-        await session.regenerate(firstId);
-        const second = client.streamChat.mock.calls[1][0];
-        expect(second).toMatchObject({ message: 'first', replaces: firstId, conversationId: 'c-1' });
-        expect(session.messages.map((m) => m.text)).toEqual(['first', 'Answer 2']);
-        await session.edit(second.requestId, 'first, but better');
-        expect(client.streamChat.mock.calls[2][0]).toMatchObject({
-            message: 'first, but better',
-            replaces: second.requestId,
-        });
-        expect(session.messages.map((m) => m.text)).toEqual(['first, but better', 'Answer 3']);
-    });
-    it('sends a normal message without replaces', async () => {
-        const client = fakeClient();
-        const session = new ChatSession({ client: client });
-        await session.send('hi');
-        expect(client.streamChat.mock.calls[0][0]).not.toHaveProperty('replaces');
-    });
-});
-describe('AgentChat regenerate and edit', () => {
-    it('offers Regenerate on the latest answer and Edit on the latest question', async () => {
-        const user = userEvent.setup();
-        const client = fakeClient();
-        render(AgentChat, { props: { client: client, sandboxOrigin: 'https://frame.test' } });
-        await user.type(screen.getByRole('textbox', { name: 'Message' }), 'one{Enter}');
-        await screen.findAllByText('Answer 1');
-        await user.type(screen.getByRole('textbox', { name: 'Message' }), 'two{Enter}');
-        await screen.findAllByText('Answer 2');
-        // Only the latest turn.
-        expect(screen.getAllByRole('button', { name: 'Regenerate response' })).toHaveLength(1);
-        expect(screen.getAllByRole('button', { name: 'Edit message' })).toHaveLength(1);
-        await user.click(screen.getByRole('button', { name: 'Regenerate response' }));
-        await waitFor(() => expect(client.streamChat).toHaveBeenCalledTimes(3));
-        expect(client.streamChat.mock.calls[2][0]).toMatchObject({ message: 'two' });
-        expect((await screen.findAllByText('Answer 3')).length).toBeGreaterThan(0);
-        expect(screen.queryByText('Answer 2')).toBeNull();
-        await user.click(screen.getByRole('button', { name: 'Edit message' }));
-        const field = screen.getByRole('textbox', { name: 'Edited message' });
-        await user.clear(field);
-        await user.type(field, 'two, edited{Enter}');
-        await waitFor(() => expect(client.streamChat).toHaveBeenCalledTimes(4));
-        expect(client.streamChat.mock.calls[3][0]).toMatchObject({
-            message: 'two, edited',
-            replaces: client.streamChat.mock.calls[2][0].requestId,
-        });
-        expect(await screen.findByText('two, edited')).toBeTruthy();
-        expect(screen.queryByText(/^two$/)).toBeNull();
-    });
-    it('cancels an edit with Escape', async () => {
-        const user = userEvent.setup();
-        const client = fakeClient();
-        render(AgentChat, { props: { client: client, sandboxOrigin: 'https://frame.test' } });
-        await user.type(screen.getByRole('textbox', { name: 'Message' }), 'one{Enter}');
-        await screen.findAllByText('Answer 1');
-        await user.click(screen.getByRole('button', { name: 'Edit message' }));
-        await user.type(screen.getByRole('textbox', { name: 'Edited message' }), ' more{Escape}');
-        expect(screen.queryByRole('textbox', { name: 'Edited message' })).toBeNull();
-        expect(screen.getByText('one')).toBeTruthy();
-        expect(client.streamChat).toHaveBeenCalledOnce();
-    });
-});

package/dist/components/welcome.svelte.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=welcome.svelte.test.d.ts.map

package/dist/components/welcome.svelte.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"welcome.svelte.test.d.ts","sourceRoot":"","sources":["../../src/lib/components/welcome.svelte.test.ts"],"names":[],"mappings":""}

package/dist/components/welcome.svelte.test.js

@@ -1,119 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { cleanup, render, screen, waitFor } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import { greeting, suggestionText } from '../welcome.js';
-import AgentChat from './AgentChat.svelte';
-import Welcome from './Welcome.svelte';
-afterEach(() => cleanup());
-function fakeClient(getConversation = vi.fn()) {
-    return {
-        fileUrl: (id) => `#${id}`,
-        uploadFile: vi.fn(),
-        cancel: vi.fn(),
-        getConversation,
-        resumeTurn: vi.fn(),
-        streamChat: vi.fn(async (req, opts) => {
-            [
-                { type: 'start', conversationId: 'c-1', mode: 'live' },
-                { type: 'delta', text: 'Sure.' },
-                { type: 'done', finishReason: 'stop' },
-            ].forEach((e, seq) => opts.onEvent({ requestId: req.requestId, seq, ...e }));
-            return { kind: 'done' };
-        }),
-    };
-}
-const base = { sandboxOrigin: 'https://frame.test' };
-describe('welcome helpers', () => {
-    it('greets by the time of day and the first name only', () => {
-        expect(greeting('Pat Lee', new Date(2026, 10, 4, 9))).toBe('Good morning, Pat');
-        expect(greeting(undefined, new Date(2026, 10, 4, 14))).toBe('Good afternoon');
-        expect(greeting('  ', new Date(2026, 10, 4, 20))).toBe('Good evening');
-        expect(greeting('Sam', new Date(2026, 10, 4, 2))).toBe('Good evening, Sam');
-    });
-    it('sends the text, or the label without one', () => {
-        expect(suggestionText({ label: 'Open lots' })).toBe('Open lots');
-        expect(suggestionText({ label: 'Lots', text: ' List open lots ' })).toBe('List open lots');
-    });
-});
-describe('Welcome', () => {
-    it('shows at most four suggestions and reports the chosen one', async () => {
-        const onselect = vi.fn();
-        render(Welcome, {
-            props: {
-                name: 'Pat',
-                title: 'Hi Pat',
-                onselect,
-                suggestions: ['A', 'B', 'C', 'D', 'E'].map((label) => ({ label, text: `Do ${label}` })),
-            },
-        });
-        expect(screen.getByRole('heading', { name: 'Hi Pat' })).toBeTruthy();
-        const list = screen.getByRole('list', { name: 'Suggestions' });
-        expect(list.querySelectorAll('button')).toHaveLength(4);
-        await userEvent.click(screen.getByRole('button', { name: 'B' }));
-        expect(onselect).toHaveBeenCalledWith('Do B', expect.objectContaining({ label: 'B' }));
-    });
-});
-describe('AgentChat empty states', () => {
-    it('welcomes a new chat and sends a chosen suggestion', async () => {
-        const client = fakeClient();
-        render(AgentChat, {
-            props: {
-                ...base,
-                client: client,
-                userName: 'Pat Lee',
-                suggestions: [{ label: 'Open lots', text: 'List the open lots' }],
-            },
-        });
-        expect(screen.getByRole('heading', { name: /, Pat$/ })).toBeTruthy();
-        await userEvent.click(screen.getByRole('button', { name: 'Open lots' }));
-        await waitFor(() => expect(client.streamChat).toHaveBeenCalledOnce());
-        expect(client.streamChat.mock.calls[0][0]).toMatchObject({ message: 'List the open lots' });
-        expect((await screen.findAllByText('Sure.')).length).toBeGreaterThan(0);
-        expect(document.querySelector('[data-agent-welcome]')).toBeNull();
-    });
-    it('shows a skeleton, not the welcome, while a conversation loads', async () => {
-        let resolve;
-        const client = fakeClient(vi.fn(() => new Promise((r) => (resolve = r))));
-        render(AgentChat, { props: { ...base, client: client, conversationId: 'c-9' } });
-        expect(document.querySelector('[data-agent-loading]')).toBeTruthy();
-        expect(document.querySelector('[data-agent-welcome]')).toBeNull();
-        resolve({
-            conversation: { conversationId: 'c-9', activeRequestId: null },
-            messages: [
-                {
-                    id: 'u-1',
-                    role: 'user',
-                    content: [{ type: 'text', text: 'Earlier question' }],
-                    createdAt: Date.now(),
-                },
-            ],
-        });
-        expect(await screen.findByText('Earlier question')).toBeTruthy();
-        expect(document.querySelector('[data-agent-loading]')).toBeNull();
-    });
-    it('explains a failed load and retries it', async () => {
-        const getConversation = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('Network down'))
-            .mockResolvedValueOnce({
-            conversation: { conversationId: 'c-9', activeRequestId: null },
-            messages: [],
-        });
-        render(AgentChat, {
-            props: { ...base, client: fakeClient(getConversation), conversationId: 'c-9' },
-        });
-        expect(await screen.findByText('Could not load this conversation.')).toBeTruthy();
-        expect(document.querySelector('[data-agent-welcome]')).toBeNull();
-        // No automatic retry loop.
-        await new Promise((r) => setTimeout(r, 50));
-        expect(getConversation).toHaveBeenCalledOnce();
-        await userEvent.click(screen.getByRole('button', { name: /Try again/ }));
-        await waitFor(() => expect(getConversation).toHaveBeenCalledTimes(2));
-        await waitFor(() => expect(screen.queryByText('Could not load this conversation.')).toBeNull());
-        expect(document.querySelector('[data-agent-welcome]')).toBeTruthy();
-    });
-    it('renders the welcome when the host gives no empty snippet', () => {
-        render(AgentChat, { props: { ...base, client: fakeClient() } });
-        expect(document.querySelector('[data-agent-welcome]')).toBeTruthy();
-    });
-});

package/dist/composer-keys.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=composer-keys.test.d.ts.map

package/dist/composer-keys.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composer-keys.test.d.ts","sourceRoot":"","sources":["../src/lib/composer-keys.test.ts"],"names":[],"mappings":""}

package/dist/composer-keys.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { composerKeyAction } from './composer-keys.js';
-describe('composerKeyAction', () => {
-    it('sends on Enter and keeps Shift+Enter for a newline', () => {
-        expect(composerKeyAction({ key: 'Enter' }, false)).toBe('send');
-        expect(composerKeyAction({ key: 'Enter', shiftKey: true }, false)).toBeNull();
-    });
-    it('ignores Enter that confirms an IME candidate', () => {
-        expect(composerKeyAction({ key: 'Enter', isComposing: true }, false)).toBeNull();
-        expect(composerKeyAction({ key: 'Enter', keyCode: 229 }, false)).toBeNull();
-    });
-    it('stops a running reply on Escape only while streaming', () => {
-        expect(composerKeyAction({ key: 'Escape' }, true)).toBe('cancel');
-        expect(composerKeyAction({ key: 'Escape' }, false)).toBeNull();
-    });
-});

package/dist/markdown.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=markdown.test.d.ts.map

package/dist/markdown.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.test.d.ts","sourceRoot":"","sources":["../src/lib/markdown.test.ts"],"names":[],"mappings":""}