@vibesdotdev/chat 0.0.0-stage → 1.0.0-rc.0

package/dist/tui/chat.tui-state.impl.consumer.js

@@ -0,0 +1,929 @@
+import * as z from 'zod/v4';
+import { settleNow, CaughtFailureSchema as ChatCaughtFailureSchema } from '@vibesdotdev/kernel';
+import { getVibesChatClient } from "../client/helper.js";
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { chatRoomsStateKey } from "./chat.tui-state.key.js";
+import { getLogger } from '@vibesdotdev/logging';
+import { runChatOwnedTask } from "../utils/owned-task.js";
+function isSelectRoom(a) {
+    return a.type === 'SELECT_ROOM';
+}
+function isSendMessage(a) {
+    return a.type === 'SEND_MESSAGE';
+}
+function isCancelGeneration(a) {
+    return a.type === 'CANCEL_GENERATION';
+}
+function isCreateRoom(a) {
+    return a.type === 'CREATE_ROOM';
+}
+function isUpdateSettings(a) {
+    return a.type === 'UPDATE_SETTINGS';
+}
+function isAddAgent(a) {
+    return a.type === 'ADD_AGENT';
+}
+function isSetAgents(a) {
+    return a.type === 'SET_AGENTS';
+}
+function isResolveApproval(a) {
+    return a.type === 'RESOLVE_APPROVAL';
+}
+const scratchByContext = new WeakMap();
+function createScratch() {
+    return {
+        session: null,
+        activeSelect: null,
+        activeSend: null,
+        activeCancelGeneration: null,
+        activeCreateRoom: null,
+        activeRefresh: null,
+        activeUpdateSettings: null,
+        activeAddAgent: null,
+        activeSetAgents: null,
+        activeResolveApproval: null,
+        pendingOptimistic: null
+    };
+}
+function roomsFromSnapshot(rooms) {
+    return Object.values(rooms);
+}
+function unavailableComposerOptions() {
+    return {
+        models: [],
+        agents: [],
+        folders: [],
+        degraded: ['models', 'agents', 'folders']
+    };
+}
+async function loadComposerOptions(runtime, client) {
+    try {
+        return await client.getComposerOptions();
+    }
+    catch (error) {
+        const diagnostics = runtime.diagnostics;
+        settleNow(() => diagnostics.error('Chat composer options failed', {
+            scope: 'chat:tui', plugin: 'chat', error: ChatCaughtFailureSchema.parse(error)
+        }));
+        getLogger('chat.tui.state', runtime).warn('Composer options are unavailable; using the unavailable placeholder', {
+            error: ChatCaughtFailureSchema.parse(error)
+        });
+        return unavailableComposerOptions();
+    }
+}
+function chatModesFromRuntime(runtime) {
+    if (!runtime.hasKind('chat/mode'))
+        return [];
+    return runtime.query('chat/mode').enabled().descriptors();
+}
+async function resolveChatClient(runtime) {
+    return getVibesChatClient(runtime);
+}
+async function linkRoomToCodeSession(runtime, sessionId, roomId) {
+    const client = await getVibesClient('code-sessions', runtime);
+    await client.link(sessionId, { kind: 'chat-room', id: roomId, source: 'chat', role: 'belongs-to' });
+}
+function unbindMessages(scratch) {
+    const s = scratch.session;
+    // A pending approval must not outlive its room binding — deny it so the
+    // blocked run can finish instead of hanging on a prompt nobody can answer.
+    scratch.activeResolveApproval?.(false);
+    if (!s)
+        return;
+    s.roomUnsub?.();
+    s.roomUnsub = null;
+    s.messagesUnsub?.();
+    s.messagesUnsub = null;
+    s.participantsUnsub?.();
+    s.participantsUnsub = null;
+    s.roomEventsUnsub?.();
+    s.roomEventsUnsub = null;
+    s.approvalUnsub?.();
+    s.approvalUnsub = null;
+}
+/**
+ * Run one dispatched client operation as work the TUI runtime owns: it never
+ * rejects into the store, and a failure lands in state as the visible error.
+ */
+function dispatchOwned(ctx, reason, work) {
+    void runChatOwnedTask(ctx.runtime, () => work(), {
+        reason: `chat tui ${reason}`,
+        onFailure: (failure) => ctx.setState((prev) => ({ ...prev, error: failure.message, loading: false }))
+    });
+}
+const impl = {
+    key: chatRoomsStateKey,
+    async init(ctx) {
+        const runtime = ctx.runtime;
+        const logger = getLogger('chat.tui.state', runtime);
+        const scratch = createScratch();
+        scratchByContext.set(ctx, scratch);
+        const chatModes = chatModesFromRuntime(runtime);
+        /**
+         * Reconcile a publish against the pending optimistic user row: keep the
+         * temp row visible until the real user message lands (matched by
+         * role + content + recency — the run generates its own message id, so
+         * the temp id can't be threaded through), then drop it and report the
+         * match so `sending` clears the moment the message is really in.
+         */
+        const reconcileOptimistic = (messages) => {
+            const pending = scratch.pendingOptimistic;
+            if (!pending)
+                return { rows: messages, landed: false };
+            if (pending.roomId !== scratch.session?.activeRoomId)
+                return { rows: messages, landed: false };
+            const landed = messages.some((message) => message.role === 'user' &&
+                message.content === pending.content &&
+                Date.parse(message.createdAt ?? '') >= pending.sentAt - 15_000);
+            if (landed) {
+                scratch.pendingOptimistic = null;
+                return { rows: messages, landed: true };
+            }
+            return { rows: [...messages, pending.message], landed: false };
+        };
+        const publishMessages = (messages) => {
+            const { rows, landed } = reconcileOptimistic(messages);
+            ctx.setState((prev) => ({
+                ...prev,
+                messages: rows,
+                sending: landed ? false : prev.sending,
+                lastUpdated: Date.now()
+            }));
+        };
+        const publishParticipants = (participants) => {
+            ctx.setState((prev) => ({
+                ...prev,
+                participants,
+                lastUpdated: Date.now()
+            }));
+        };
+        const publishRoom = (room) => {
+            ctx.setState((prev) => ({
+                ...prev,
+                activeRoom: room,
+                lastUpdated: Date.now()
+            }));
+        };
+        const publishError = (message) => {
+            ctx.setState((prev) => ({
+                ...prev,
+                loaded: true,
+                loading: false,
+                sending: false,
+                generating: false,
+                error: message,
+                lastUpdated: Date.now()
+            }));
+        };
+        // Resolve + load the chat client. A failure here (e.g. the `chat/client`
+        // kind not registered in this scope, or storage init throwing) must NOT
+        // propagate: `TuiStateProvider` only logs a thrown init and never sets the
+        // store value, which leaves the surface stuck on "Preparing the live chat
+        // workspace" forever. Return a loaded error-state instead so the surface
+        // renders its error path (banner + Refresh) and the user can recover.
+        let client;
+        try {
+            client = await resolveChatClient(runtime);
+            // Runtime boundary: ensureLoaded exists on RuntimeChatClient runtime instance
+            await client.ensureLoaded();
+        }
+        catch (err) {
+            const diagnostics = runtime.diagnostics;
+            settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+            return {
+                rooms: [],
+                activeRoomId: null,
+                messages: [],
+                activeRoom: null,
+                chatModes,
+                composerOptions: unavailableComposerOptions(),
+                participants: [],
+                pendingApproval: null,
+                modelLoading: null,
+                loaded: true,
+                loading: false,
+                sending: false,
+                generating: false,
+                authenticated: false,
+                error: err instanceof Error ? err.message : String(err),
+                lastUpdated: Date.now()
+            };
+        }
+        // Local-first auth: a chat client that loaded against the local runtime IS
+        // authenticated for the person operating it. The cloud bearer token that
+        // `RuntimeChatClient.isAuthenticated()` checks for is only needed to reach
+        // cloud chat, and its absence must never render as "not signed in" on a
+        // local TUI — the diagnostic lie Drew's /chat review caught
+        // (TUI-WEB-PARITY-DESIGN.md §auth "one story"). A genuine load/auth failure
+        // takes the catch path above, which sets `authenticated: false` with the error.
+        const authenticated = true;
+        // The storage-manifest cache can hand back a snapshot whose `activeRoomId`
+        // lags the rooms load, so remember the last non-null one we ever see and use
+        // it as a fallback when restoring the active room below.
+        let lastAdoptRoomId = null;
+        const roomsUnsub = client.rooms.subscribe((snapshot) => {
+            const rows = roomsFromSnapshot(snapshot.rooms);
+            const adoptRoomId = snapshot.activeRoomId;
+            if (adoptRoomId)
+                lastAdoptRoomId = adoptRoomId;
+            ctx.setState((prev) => ({
+                ...prev,
+                rooms: rows,
+                activeRoomId: prev.activeRoomId ?? adoptRoomId,
+                chatModes,
+                loaded: true,
+                loading: false,
+                authenticated,
+                error: null,
+                lastUpdated: Date.now()
+            }));
+            // A room adopted from the persisted snapshot must still LOAD its
+            // messages/participants and bind the live subscriptions — `select()` is
+            // the only path that does. Without this, the auto-selected active room
+            // renders with "0 messages" / "no agent" and never updates on new
+            // messages. Guard on `session.activeRoomId` so we never clobber a
+            // user-initiated selection that's already in flight/loaded.
+            if (scratch.session && !scratch.session.activeRoomId && adoptRoomId) {
+                void scratch.activeSelect?.(adoptRoomId);
+            }
+        });
+        scratch.session = {
+            client,
+            roomsUnsub,
+            roomUnsub: null,
+            messagesUnsub: null,
+            participantsUnsub: null,
+            roomEventsUnsub: null,
+            approvalUnsub: null,
+            activeRoomId: null,
+            selectSettled: null
+        };
+        const select = async (roomId) => {
+            if (!scratch.session)
+                return;
+            if (scratch.session.activeRoomId === roomId)
+                return;
+            unbindMessages(scratch);
+            // The optimistic row (and any in-flight send/generation affordance)
+            // belongs to the room the user just left.
+            if (scratch.pendingOptimistic && scratch.pendingOptimistic.roomId !== roomId) {
+                scratch.pendingOptimistic = null;
+            }
+            scratch.session.activeRoomId = roomId;
+            let settle = () => { };
+            scratch.session.selectSettled = new Promise((resolve) => {
+                settle = resolve;
+            });
+            ctx.setState((prev) => ({
+                ...prev,
+                activeRoomId: roomId,
+                activeRoom: null,
+                participants: [],
+                messages: [],
+                pendingApproval: null,
+                modelLoading: null,
+                sending: false,
+                generating: false,
+                error: roomId ? null : prev.error
+            }));
+            if (!roomId) {
+                settle();
+                return;
+            }
+            try {
+                const room = await scratch.session.client.rooms.get(roomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${roomId}`);
+                const initial = await room.messages.list({
+                    limit: 100,
+                    direction: 'before'
+                });
+                const participants = await room.participants.list();
+                // Stale-select guard: a newer select() may have started while the
+                // loads above were in flight. Binding THIS room's subscriptions now
+                // would clobber the newer selection's session slots (leaking its
+                // subscriptions) and publish this room's messages into the other
+                // room's view. The loser backs off; the newest select owns the state.
+                if (!scratch.session || scratch.session.activeRoomId !== roomId)
+                    return;
+                const roomUnsub = room.subscribe((next) => {
+                    publishRoom(next);
+                });
+                const messagesUnsub = room.messages.subscribe((messages) => {
+                    publishMessages(messages);
+                });
+                const participantsUnsub = room.participants.subscribe((next) => {
+                    publishParticipants(next);
+                });
+                // Incremental streaming: chunk/tool events mutate the room handle's
+                // IN-MEMORY data (applyChunkToRoom) long before the final storage
+                // write, while `messages.subscribe` re-reads storage and therefore
+                // only fires on create + final update. Publishing from room.data on
+                // stream events is what makes tokens appear as they generate.
+                const publishLiveMessages = () => {
+                    const items = room.data.items ?? [];
+                    const live = items
+                        .filter((item) => item.type === 'message')
+                        .map((item) => item.data);
+                    if (live.length > 0)
+                        publishMessages(live);
+                };
+                const eventsUnsub = room.onEvent((event) => {
+                    // Lifecycle flags, decoupled: `sending` ends when the USER message
+                    // is really created (the message flight); `generating` follows the
+                    // run itself — asserted by liveness events (so a stale `done` from
+                    // a just-cancelled run can't strand the NEW run without its
+                    // affordance) and cleared when the run settles (done/error).
+                    if (event.type === 'message.created' && event.role === 'user') {
+                        ctx.setState((prev) => prev.sending ? { ...prev, sending: false, lastUpdated: Date.now() } : prev);
+                    }
+                    // Waiting on a LOAD, not on thinking. The liveness branch below clears
+                    // it the instant real output starts, so the two never both show.
+                    if (event.type === 'model.loading') {
+                        ctx.setState((prev) => ({
+                            ...prev,
+                            modelLoading: {
+                                modelId: event.modelId,
+                                message: event.message || undefined
+                            },
+                            lastUpdated: Date.now()
+                        }));
+                    }
+                    const isLiveness = event.type === 'chunk' ||
+                        event.type === 'reasoning' ||
+                        (event.type === 'message.created' && event.role === 'assistant') ||
+                        event.type.startsWith('tool.');
+                    if (isLiveness) {
+                        ctx.setState((prev) => prev.generating && prev.modelLoading === null
+                            ? prev
+                            : { ...prev, generating: true, modelLoading: null, lastUpdated: Date.now() });
+                    }
+                    if (event.type === 'done' || event.type === 'error') {
+                        ctx.setState((prev) => prev.generating || prev.sending || prev.modelLoading
+                            ? {
+                                ...prev,
+                                generating: false,
+                                sending: false,
+                                modelLoading: null,
+                                lastUpdated: Date.now()
+                            }
+                            : prev);
+                    }
+                    if (event.type === 'chunk' ||
+                        event.type === 'reasoning' ||
+                        event.type === 'message.created' ||
+                        event.type === 'message.updated' ||
+                        event.type.startsWith('tool.')) {
+                        publishLiveMessages();
+                    }
+                });
+                // Tool-approval gate: while this room is active, gated tool calls
+                // pause the run and surface here. Publishing pendingApproval renders
+                // the approval bar; RESOLVE_APPROVAL fulfils the promise and unblocks
+                // (or denies) the agent loop.
+                const approvalUnsub = room.onApprovalRequest((request) => {
+                    // Fail-closed: a request from a run whose room is no longer the
+                    // active one has no bar the user could attribute — pressing A
+                    // would approve an invisible tool call from another room. Deny.
+                    if (!scratch.session || scratch.session.activeRoomId !== roomId) {
+                        return Promise.resolve({
+                            approved: false,
+                            reason: 'The room is no longer active in this surface'
+                        });
+                    }
+                    return new Promise((resolve) => {
+                        scratch.activeResolveApproval = (approved, workspaceAccessChoice) => {
+                            scratch.activeResolveApproval = null;
+                            ctx.setState((prev) => ({
+                                ...prev,
+                                pendingApproval: null,
+                                modelLoading: null,
+                                lastUpdated: Date.now()
+                            }));
+                            resolve({
+                                approved,
+                                reason: workspaceAccessChoice === 'always' ? 'always' : undefined,
+                                workspaceAccessChoice
+                            });
+                        };
+                        ctx.setState((prev) => ({
+                            ...prev,
+                            pendingApproval: {
+                                toolName: request.toolName,
+                                input: request.args,
+                                description: request.description || undefined,
+                                workspaceAccess: request.workspaceAccess
+                            },
+                            lastUpdated: Date.now()
+                        }));
+                    });
+                });
+                scratch.session.roomUnsub = roomUnsub;
+                scratch.session.messagesUnsub = messagesUnsub;
+                scratch.session.participantsUnsub = participantsUnsub;
+                scratch.session.roomEventsUnsub = eventsUnsub;
+                scratch.session.approvalUnsub = approvalUnsub;
+                // Reconcile so a send dispatched while this selection was still
+                // loading (the queued initial-message path) keeps its optimistic row.
+                const { rows: initialRows } = reconcileOptimistic(initial);
+                ctx.setState((prev) => ({
+                    ...prev,
+                    activeRoom: room.data,
+                    participants,
+                    messages: initialRows,
+                    lastUpdated: Date.now()
+                }));
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+            finally {
+                settle();
+            }
+        };
+        scratch.activeSelect = select;
+        // The `client.rooms.subscribe(...)` initial emission above fires synchronously,
+        // BEFORE `session`/`activeSelect` exist, so its adopt guard is skipped. Now that
+        // both are wired, restore the persisted active room directly. Poll briefly:
+        // `getActiveId()` (and the subscribe snapshot) can transiently return null while
+        // the storage-manifest cache settles, which used to strand the room on the picker.
+        void runChatOwnedTask(runtime, async (signal) => {
+            for (let attempt = 0; attempt < 10; attempt++) {
+                if (!scratch.session || scratch.session.activeRoomId)
+                    return;
+                let persisted = null;
+                try {
+                    persisted = await client.rooms.getActiveId();
+                }
+                catch (error) {
+                    const diagnostics = runtime.diagnostics;
+                    settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(error) }));
+                    logger.warn('The persisted active room id could not be read; using the captured snapshot id', { error });
+                }
+                persisted = persisted ?? lastAdoptRoomId;
+                if (persisted) {
+                    await scratch.activeSelect?.(persisted);
+                    return;
+                }
+                // Disposal rejects the delay CANCELLED, which ends the owned poll quietly.
+                await runtime.lifecycle.delay(50, signal);
+            }
+        }, { reason: 'chat tui active room restore', timeoutMs: 30_000 });
+        /**
+         * Convert the optimistic row to a failed state (preserving the typed
+         * text) and surface the error. The failed row stays visible — the text
+         * is the user's work; a silent disappearance would eat it.
+         */
+        const failOptimistic = (tempId, message) => {
+            if (scratch.pendingOptimistic?.tempId !== tempId)
+                return;
+            const pending = scratch.pendingOptimistic;
+            if (pending?.tempId === tempId) {
+                const failed = {
+                    ...pending.message,
+                    status: 'failed',
+                    metadata: { ...pending.message.metadata, error: message }
+                };
+                scratch.pendingOptimistic = { ...pending, message: failed };
+            }
+            ctx.setState((prev) => ({
+                ...prev,
+                messages: prev.messages.map((row) => String(row.id) === tempId && scratch.pendingOptimistic ? scratch.pendingOptimistic.message : row),
+                loaded: true,
+                loading: false,
+                sending: false,
+                generating: false,
+                error: message,
+                lastUpdated: Date.now()
+            }));
+        };
+        const send = async (content) => {
+            if (!scratch.session?.activeRoomId) {
+                publishError('No active room — select a room first.');
+                return;
+            }
+            const trimmed = content.trim();
+            if (trimmed.length === 0)
+                return;
+            const roomId = scratch.session.activeRoomId;
+            // The user moved on: room.send() cancels any in-flight run, so a
+            // pending approval belongs to a run that is about to die. Deny it
+            // (fail-closed) so the bar clears and the paused loop unblocks.
+            scratch.activeResolveApproval?.(false);
+            // Optimistic send: the user's row appears AT DISPATCH (status
+            // 'sending'), is reconciled away when the real message.created lands,
+            // and converts to a failed row (text preserved) if the send throws.
+            const sentAt = Date.now();
+            const tempId = `temp-${crypto.randomUUID()}`;
+            const tempMessage = {
+                id: tempId,
+                roomId,
+                role: 'user',
+                senderType: 'user',
+                content: trimmed,
+                status: 'sending',
+                createdAt: new Date(sentAt).toISOString()
+            };
+            scratch.pendingOptimistic = { tempId, roomId, content: trimmed, sentAt, message: tempMessage };
+            ctx.setState((prev) => ({
+                ...prev,
+                // A previous failed/stale temp row is superseded by this send.
+                messages: [
+                    ...prev.messages.filter((row) => !String(row.id).startsWith('temp-')),
+                    tempMessage
+                ],
+                sending: true,
+                generating: true,
+                error: null,
+                lastUpdated: Date.now()
+            }));
+            try {
+                // Selection bindings — including the tool-approval handler — must be
+                // in place before the run starts: a run captures the approval handler
+                // at start, so racing ahead of select() would execute dangerous tools
+                // with NO approval gate (the queued initial-message path hit this).
+                await scratch.session.selectSettled;
+                if (!scratch.session || scratch.session.activeRoomId !== roomId) {
+                    failOptimistic(tempId, 'Active room changed — the message was not sent.');
+                    return;
+                }
+                const room = await scratch.session.client.rooms.get(roomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${roomId}`);
+                await room.send({ content: trimmed });
+                ctx.setState((prev) => ({
+                    ...prev,
+                    sending: false,
+                    generating: false,
+                    lastUpdated: Date.now()
+                }));
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                failOptimistic(tempId, err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeSend = send;
+        scratch.activeCancelGeneration = async () => {
+            if (!scratch.session?.activeRoomId)
+                return;
+            const roomId = scratch.session.activeRoomId;
+            scratch.activeResolveApproval?.(false);
+            try {
+                const room = await scratch.session.client.rooms.get(roomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${roomId}`);
+                await Promise.resolve(room.cancel());
+                ctx.setState((prev) => ({
+                    ...prev,
+                    pendingApproval: null,
+                    modelLoading: null,
+                    sending: false,
+                    generating: false,
+                    error: null,
+                    lastUpdated: Date.now()
+                }));
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        const createRoom = async (input) => {
+            if (!scratch.session)
+                return;
+            const participants = input?.participants ?? [];
+            ctx.setState((prev) => ({ ...prev, loading: true, error: null }));
+            try {
+                const room = await scratch.session.client.rooms.create({
+                    ...input?.room,
+                    participants,
+                    roomMode: participants.length > 0 && input?.room?.roomMode === undefined
+                        ? 'multi'
+                        : input?.room?.roomMode
+                });
+                ctx.setState((prev) => ({
+                    ...prev,
+                    rooms: prev.rooms.some((candidate) => String(candidate.id) === room.id)
+                        ? prev.rooms
+                        : [...prev.rooms, room.data],
+                    loading: false,
+                    lastUpdated: Date.now()
+                }));
+                // New-room sends must use the same fail-closed binding sequence as
+                // existing rooms: create -> select/bind approval -> send.
+                await select(room.id);
+                const codeSessionId = z.string().trim().min(1).safeParse(input?.room?.metadata?.codeSessionId);
+                if (codeSessionId.success) {
+                    // The room exists and is selected before relationship persistence.
+                    // If the owner write fails, stop before auto-sending: the room stays
+                    // usable, while the request is not launched into work Home cannot resume.
+                    await linkRoomToCodeSession(runtime, codeSessionId.data, room.id);
+                }
+                const initialMessage = input?.initialMessage?.trim();
+                if (initialMessage)
+                    await send(initialMessage);
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeCreateRoom = createRoom;
+        const updateSettings = async (patch) => {
+            if (!scratch.session?.activeRoomId) {
+                publishError('No active room — select a room before changing chat settings.');
+                return;
+            }
+            const roomId = scratch.session.activeRoomId;
+            ctx.setState((prev) => ({ ...prev, loading: true, error: null }));
+            try {
+                const room = await scratch.session.client.rooms.get(roomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${roomId}`);
+                await room.updateSettings(patch);
+                const updated = room.data;
+                ctx.setState((prev) => ({
+                    ...prev,
+                    loading: false,
+                    activeRoom: updated,
+                    rooms: prev.rooms.map((row) => (String(row.id) === roomId ? updated : row)),
+                    lastUpdated: Date.now()
+                }));
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeUpdateSettings = updateSettings;
+        const setAgents = async (input) => {
+            if (!scratch.session?.activeRoomId) {
+                publishError('No active room — select a room before changing agents.');
+                return;
+            }
+            const roomId = scratch.session.activeRoomId;
+            ctx.setState((prev) => ({ ...prev, loading: true, error: null }));
+            try {
+                const room = await scratch.session.client.rooms.get(roomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${roomId}`);
+                const current = await room.participants.list();
+                const currentAgents = new Map(current
+                    .filter((participant) => participant.type === 'agent')
+                    .map((participant) => [participant.id, participant]));
+                const desiredAgents = new Map();
+                for (const agent of input.agents) {
+                    const id = agent.id.trim();
+                    if (agent.type !== 'agent' || !id)
+                        continue;
+                    desiredAgents.set(id, { ...agent, id, type: 'agent' });
+                }
+                for (const existing of currentAgents.values()) {
+                    if (!desiredAgents.has(existing.id)) {
+                        await room.participants.remove(`agent:${existing.id}`);
+                    }
+                }
+                for (const desired of desiredAgents.values()) {
+                    const existing = currentAgents.get(desired.id);
+                    if (existing) {
+                        await room.participants.update(`agent:${desired.id}`, {
+                            name: desired.name,
+                            description: desired.description,
+                            modelHint: desired.modelHint,
+                            responseStyle: desired.responseStyle ?? existing.responseStyle,
+                            enabled: true,
+                            source: desired.source ?? existing.source
+                        });
+                    }
+                    else {
+                        await room.participants.add({
+                            ...desired,
+                            enabled: true,
+                            responseStyle: desired.responseStyle ?? 'auto',
+                            source: desired.source ?? 'runtime'
+                        });
+                    }
+                }
+                const participants = await room.participants.list();
+                await room.updateSettings({ roomMode: participants.length > 0 ? 'multi' : 'standard' });
+                ctx.setState((prev) => ({
+                    ...prev,
+                    loading: false,
+                    activeRoom: room.data,
+                    rooms: prev.rooms.map((candidate) => String(candidate.id) === roomId ? room.data : candidate),
+                    participants,
+                    lastUpdated: Date.now()
+                }));
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeSetAgents = setAgents;
+        const addAgent = async (input) => {
+            if (!scratch.session?.activeRoomId) {
+                publishError('No active room — select a room before adding an agent.');
+                return;
+            }
+            const agentId = input.agentId.trim();
+            if (!agentId) {
+                publishError('No agent selected.');
+                return;
+            }
+            try {
+                const room = await scratch.session.client.rooms.get(scratch.session.activeRoomId);
+                if (!room)
+                    throw new Error(`Chat room not found: ${scratch.session.activeRoomId}`);
+                const participants = await room.participants.list();
+                const agents = participants
+                    .filter((participant) => participant.type === 'agent')
+                    .map((participant) => ({ ...participant, type: 'agent' }));
+                const next = agents.filter((agent) => agent.id !== agentId);
+                next.push({
+                    id: agentId,
+                    type: 'agent',
+                    name: input.name ?? agentId,
+                    description: input.description,
+                    modelHint: input.modelHint,
+                    enabled: true,
+                    responseStyle: 'auto',
+                    source: 'runtime'
+                });
+                await setAgents({ agents: next });
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeAddAgent = addAgent;
+        const refresh = async () => {
+            if (!scratch.session)
+                return;
+            ctx.setState((prev) => ({ ...prev, loading: true, error: null }));
+            try {
+                const [rooms, composerOptions] = await Promise.all([
+                    scratch.session.client.rooms.list(),
+                    loadComposerOptions(runtime, scratch.session.client)
+                ]);
+                // rooms.list() returns ChatRoom[]; room.data is the UnifiedChatRoom the state holds
+                const rows = rooms.map((r) => r.data);
+                ctx.setState((prev) => ({
+                    ...prev,
+                    rooms: rows,
+                    composerOptions,
+                    loaded: true,
+                    loading: false,
+                    lastUpdated: Date.now()
+                }));
+                if (scratch.session.activeRoomId) {
+                    const room = await scratch.session.client.rooms.get(scratch.session.activeRoomId);
+                    if (room) {
+                        const messages = await room.messages.list({
+                            limit: 100,
+                            direction: 'before'
+                        });
+                        publishMessages(messages);
+                    }
+                }
+            }
+            catch (err) {
+                const diagnostics = runtime.diagnostics;
+                settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+                publishError(err instanceof Error ? err.message : String(err));
+            }
+        };
+        scratch.activeRefresh = refresh;
+        // Initial load.
+        let initialRooms = [];
+        let composerOptions = unavailableComposerOptions();
+        let initialError = null;
+        try {
+            const [rooms, options] = await Promise.all([
+                client.rooms.list(),
+                loadComposerOptions(runtime, client)
+            ]);
+            // rooms.list() returns ChatRoom[]; room.data is the UnifiedChatRoom the state holds
+            initialRooms = rooms.map((r) => r.data);
+            composerOptions = options;
+        }
+        catch (err) {
+            const diagnostics = runtime.diagnostics;
+            settleNow(() => diagnostics.error('Chat operation failed', { scope: 'chat', plugin: 'chat', error: ChatCaughtFailureSchema.parse(err) }));
+            initialError = err instanceof Error ? err.message : String(err);
+        }
+        return {
+            rooms: initialRooms,
+            activeRoomId: null,
+            messages: [],
+            activeRoom: null,
+            chatModes,
+            composerOptions,
+            participants: [],
+            pendingApproval: null,
+            modelLoading: null,
+            loaded: true,
+            loading: false,
+            sending: false,
+            generating: false,
+            authenticated,
+            error: initialError,
+            lastUpdated: Date.now()
+        };
+    },
+    reduce(state, action, ctx) {
+        if (!ctx)
+            return state;
+        const scratch = scratchByContext.get(ctx);
+        if (!scratch)
+            return state;
+        if (isSelectRoom(action) && scratch.activeSelect) {
+            const run = scratch.activeSelect;
+            dispatchOwned(ctx, 'activeSelect', () => run(action.payload.roomId));
+            return state;
+        }
+        if (isSendMessage(action) && scratch.activeSend) {
+            const run = scratch.activeSend;
+            dispatchOwned(ctx, 'activeSend', () => run(action.payload.content));
+            return state;
+        }
+        if (isCancelGeneration(action) && scratch.activeCancelGeneration) {
+            const run = scratch.activeCancelGeneration;
+            dispatchOwned(ctx, 'activeCancelGeneration', () => run());
+            return state;
+        }
+        if (isCreateRoom(action) && scratch.activeCreateRoom) {
+            const run = scratch.activeCreateRoom;
+            dispatchOwned(ctx, 'activeCreateRoom', () => run(action.payload));
+            return state;
+        }
+        if (isUpdateSettings(action) && scratch.activeUpdateSettings) {
+            const run = scratch.activeUpdateSettings;
+            dispatchOwned(ctx, 'activeUpdateSettings', () => run(action.payload.patch));
+            return state;
+        }
+        if (isAddAgent(action) && scratch.activeAddAgent) {
+            const run = scratch.activeAddAgent;
+            dispatchOwned(ctx, 'activeAddAgent', () => run(action.payload));
+            return state;
+        }
+        if (isSetAgents(action) && scratch.activeSetAgents) {
+            const run = scratch.activeSetAgents;
+            dispatchOwned(ctx, 'activeSetAgents', () => run(action.payload));
+            return state;
+        }
+        if (isResolveApproval(action) && scratch.activeResolveApproval) {
+            scratch.activeResolveApproval(action.payload.approved, action.payload.workspaceAccessChoice);
+            // Return the cleared state EXPLICITLY. The resolver's ctx.setState also
+            // clears pendingApproval, but a reducer's return value is written back
+            // by the store — returning the stale input here resurrected the bar
+            // after every A/D decision (the TUI looked permanently paused while
+            // the run had long moved on).
+            return { ...state, pendingApproval: null, modelLoading: null, lastUpdated: Date.now() };
+        }
+        if (action.type === 'REFRESH' && scratch.activeRefresh) {
+            const run = scratch.activeRefresh;
+            dispatchOwned(ctx, 'activeRefresh', () => run());
+            return state;
+        }
+        return state;
+    },
+    dispose(ctx) {
+        const scratch = ctx ? scratchByContext.get(ctx) : undefined;
+        if (!scratch)
+            return;
+        scratchByContext.delete(ctx);
+        scratch.activeResolveApproval?.(false);
+        if (scratch.session) {
+            scratch.session.roomsUnsub?.();
+            scratch.session.roomUnsub?.();
+            scratch.session.messagesUnsub?.();
+            scratch.session.participantsUnsub?.();
+            scratch.session.roomEventsUnsub?.();
+            scratch.session.approvalUnsub?.();
+        }
+        scratch.session = null;
+        scratch.activeSelect = null;
+        scratch.activeSend = null;
+        scratch.activeCancelGeneration = null;
+        scratch.activeCreateRoom = null;
+        scratch.activeRefresh = null;
+        scratch.activeUpdateSettings = null;
+        scratch.activeAddAgent = null;
+        scratch.activeSetAgents = null;
+        scratch.activeResolveApproval = null;
+        scratch.pendingOptimistic = null;
+    }
+};
+export default impl;
+//# sourceMappingURL=chat.tui-state.impl.consumer.js.map