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

package/dist/svelte/stores/chat/svelte/runtime-chat-store.svelte.js

@@ -0,0 +1,617 @@
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { contextualChatStore } from "../../../surface-context.js";
+/** Svelte $state shell bound to a ChatClient. Backend-agnostic — swap via setClientFactory(). */
+import { settle } from '@vibesdotdev/kernel';
+import { mapUnifiedMessageToLegacyMessage } from "./runtime-chat-mappers.js";
+import { releaseChatClient } from "./chat-client-ownership.js";
+export class RuntimeChatStore {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    loading = $state(false);
+    ready = $state(false);
+    error = $state(null);
+    client = $state(null);
+    activeRoom = $state(null);
+    /**
+     * The current tool call awaiting the user's decision (web approval transport),
+     * or null. The approval bar renders from this; `resolveApproval` settles it and
+     * WebChatRoom POSTs the decision to the run.
+     */
+    pendingApproval = $state(null);
+    pendingApprovalMode = $state('auto-approve-safe');
+    epoch = 0;
+    roomEpoch = 0;
+    loadPromise = null;
+    approvalUnsub = null;
+    roomsUnsub = null;
+    roomUnsub = null;
+    messagesUnsub = null;
+    participantsUnsub = null;
+    eventsUnsub = null;
+    /** ID of the assistant message currently being streamed — preserves optimistic content. */
+    streamingAssistantId = null;
+    /**
+     * ID of the optimistic, empty assistant skeleton inserted the instant the
+     * user sends — shows a typing indicator immediately, then is retired and
+     * replaced by the authoritative server assistant row (~9s later) so nothing
+     * double-renders. Distinct from `streamingAssistantId`, which can point at
+     * either the placeholder (before the real row arrives) or the real row.
+     */
+    pendingAssistantPlaceholderId = null;
+    /** The semantic Chat owner is borrowed by default; hosts may override before load. */
+    clientFactory = () => getVibesClient('chat', this.stores.runtime);
+    clientOwnership = 'borrowed';
+    setClientFactory(factory, ownership) {
+        if (this.ready || this.client) {
+            throw new Error('setClientFactory must be called before load()');
+        }
+        this.clientFactory = factory;
+        this.clientOwnership = ownership;
+    }
+    load() {
+        if (this.ready && this.client)
+            return Promise.resolve();
+        if (this.loadPromise)
+            return this.loadPromise;
+        this.loadPromise = this.loadInternal();
+        return this.loadPromise;
+    }
+    async openRoom(roomId) {
+        const epoch = this.epoch;
+        await this.load();
+        if (epoch !== this.epoch)
+            return null;
+        if (!this.client)
+            return null;
+        if (!roomId) {
+            await this.client.rooms.setActiveId(null);
+            if (epoch !== this.epoch)
+                return null;
+            this.clearActiveRoom();
+            this.stores.chatRoomStore.pendingModeId = 'chat';
+            this.stores.chatRoomStore.pendingWorkspaceId = null;
+            this.stores.chatRoomStore.pendingWorkspaceLabel = null;
+            this.stores.chatRoomStore.pendingWorkspaceLocation = null;
+            this.stores.chatRoomStore.pendingCodeSessionId = null;
+            this.stores.chatRoomStore.pendingCodeSessionHostKind = null;
+            return null;
+        }
+        this.stores.chatRoomStore.isLoading = true;
+        try {
+            const client = this.client;
+            const room = await client.rooms.get(roomId);
+            if (epoch !== this.epoch)
+                return null;
+            if (!room) {
+                this.stores.chatRoomStore.loadError = `Room not found: ${roomId}`;
+                this.clearActiveRoom();
+                return null;
+            }
+            await client.rooms.setActiveId(roomId);
+            if (epoch !== this.epoch)
+                return null;
+            await this.bindRoom(room);
+            if (epoch !== this.epoch)
+                return null;
+            this.stores.chatRoomStore.loadError = null;
+            return room;
+        }
+        finally {
+            if (epoch === this.epoch)
+                this.stores.chatRoomStore.isLoading = false;
+        }
+    }
+    async createRoom(input) {
+        await this.load();
+        if (!this.client)
+            throw new Error('Chat client is not available');
+        const room = await this.client.rooms.create({
+            ...input,
+            roomMode: input?.roomMode ?? this.stores.chatRoomStore.pendingRoomMode
+        });
+        await this.openRoom(room.id);
+        return room;
+    }
+    async startConversation(input) {
+        await this.load();
+        if (!this.client)
+            throw new Error('Chat client is not available');
+        const started = await this.client.startConversation(input);
+        // Bind before recording the room as active: the surface shows the bound room,
+        // and its first turn must not wait on the host's active-room write.
+        await this.bindRoom(started.room);
+        await this.client.rooms.setActiveId(started.room.id);
+        return started;
+    }
+    async setRoomMode(mode) {
+        this.stores.chatRoomStore.pendingRoomMode = mode;
+        this.stores.chatRoomStore.roomMode = mode;
+        if (mode === 'standard') {
+            this.stores.chatUIStore.sidebarRightOpen = false;
+        }
+        else {
+            this.stores.chatUIStore.sidebarRightOpen = true;
+        }
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ roomMode: mode });
+    }
+    async setChatModeId(modeId) {
+        this.stores.chatRoomStore.pendingModeId = modeId;
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ modeId });
+    }
+    async setApprovalMode(approvalMode) {
+        if (this.activeRoom)
+            await this.activeRoom.updateSettings({ approvalMode });
+        else
+            this.pendingApprovalMode = approvalMode;
+    }
+    async setRoomVisibility(visibility) {
+        this.stores.chatRoomStore.pendingVisibility = visibility;
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ visibility });
+    }
+    async setResponseMaxTokens(maxTokens) {
+        this.stores.chatRoomStore.pendingMaxTokens = maxTokens;
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ maxTokens });
+    }
+    async setModelId(modelId) {
+        this.stores.chatRoomStore.pendingModelId = modelId;
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ modelId });
+    }
+    async setCompaction(compaction) {
+        this.stores.chatRoomStore.pendingCompaction = compaction;
+        if (!this.activeRoom)
+            return;
+        await this.activeRoom.updateSettings({ compaction });
+    }
+    async setWorkspaceBinding(input) {
+        if (this.activeRoom) {
+            throw new Error('Choose a workspace before starting a new conversation.');
+        }
+        const workspaceId = input.id.trim();
+        const label = input.label.trim();
+        const codeSessionId = input.codeSessionId?.trim() || null;
+        const codeSessionHostKind = input.codeSessionHostKind ?? null;
+        if (!workspaceId || !label || !codeSessionId || !codeSessionHostKind || input.disabled) {
+            throw new Error(input.unavailableReason ?? 'That workspace is not runnable.');
+        }
+        this.stores.chatRoomStore.pendingWorkspaceId = workspaceId;
+        this.stores.chatRoomStore.pendingWorkspaceLabel = label;
+        this.stores.chatRoomStore.pendingWorkspaceLocation = input.location;
+        this.stores.chatRoomStore.pendingCodeSessionId = codeSessionId;
+        this.stores.chatRoomStore.pendingCodeSessionHostKind = codeSessionHostKind;
+    }
+    async listFolders() {
+        await this.load();
+        if (!this.client) {
+            throw this.error ?? new Error('Chat is not connected. Reconnect and retry.');
+        }
+        return this.client.folders.list();
+    }
+    async getComposerOptions(options) {
+        await this.load();
+        if (!this.client) {
+            return { models: [], agents: [], folders: [], degraded: ['models', 'agents', 'folders'] };
+        }
+        return this.client.getComposerOptions(options);
+    }
+    async listRoomSummaries(limit = 8) {
+        await this.load();
+        if (!this.client)
+            return [];
+        const rooms = await this.client.rooms.list();
+        return rooms.slice(0, limit).map((room) => ({
+            id: room.id,
+            title: room.data.title,
+            updatedAt: room.data.updatedAt
+        }));
+    }
+    async searchMessages(query, options = {}) {
+        await this.load();
+        if (!this.client)
+            return [];
+        return this.client.search.messages({
+            query,
+            limit: options.limit,
+            signal: options.signal
+        });
+    }
+    async moveActiveRoomToFolder(folderId, folderName) {
+        this.stores.chatRoomStore.pendingFolderId = folderId;
+        const room = this.activeRoom;
+        if (!room)
+            return;
+        const sourceFolderId = (await this.listFolders()).folderItems.find((item) => item.chatRoomId === room.id)?.folderId ?? null;
+        if (sourceFolderId === folderId)
+            return;
+        await this.client?.folders.moveRoom({
+            chatRoomId: room.id,
+            sourceFolderId,
+            destinationFolderId: folderId
+        });
+        const metadata = { ...room.data.metadata };
+        if (folderId && folderName) {
+            metadata.folderId = folderId;
+            metadata.folderName = folderName;
+        }
+        else {
+            delete metadata.folderId;
+            delete metadata.folderName;
+        }
+        room.data = { ...room.data, metadata };
+        if (this.stores.chatRoomStore.room?.id === room.id) {
+            this.stores.chatRoomStore.room = { ...this.stores.chatRoomStore.room, metadata };
+        }
+    }
+    setSidebarLeftOpen(open) {
+        this.stores.chatUIStore.sidebarLeftOpen = open;
+    }
+    setSidebarRightOpen(open) {
+        this.stores.chatUIStore.sidebarRightOpen = open;
+    }
+    /**
+     * Abort the active generation run on the current room. Calling this signals
+     * the room's AbortController, which causes the in-flight `room.send()` await
+     * to reject/return, letting the caller's `finally` block flip `sending` back
+     * to `false`. No direct store state is mutated here — the abort propagates
+     * through the normal send flow.
+     */
+    async cancelGeneration() {
+        await this.activeRoom?.cancel();
+    }
+    setUserScrolling(scrolling) {
+        this.stores.chatUIStore.isUserScrolling = scrolling;
+    }
+    nudgeScrollBottom(force = false) {
+        if (force)
+            this.stores.chatUIStore.scrollNudgeForce += 1;
+        else
+            this.stores.chatUIStore.scrollNudge += 1;
+    }
+    requestGotoMessage(messageId) {
+        this.stores.chatUIStore.gotoMessageId = messageId;
+        this.stores.chatUIStore.gotoCounter += 1;
+    }
+    dispose() {
+        this.epoch += 1;
+        const client = this.client;
+        const ownership = this.clientOwnership;
+        this.clearSubscriptions();
+        this.loadPromise = null;
+        this.loading = false;
+        this.activeRoom = null;
+        this.client = null;
+        this.ready = false;
+        // Ambient runtime-registry clients are process-scoped and borrowed. This
+        // surface releases only its subscriptions in that case, so another Chat or
+        // Inbox consumer keeps its cached room handles and realtime transport alive.
+        // Caller-created and consumer-session factories opt into owned disposal.
+        releaseChatClient(client, ownership);
+    }
+    async loadInternal() {
+        const epoch = this.epoch;
+        this.loading = true;
+        this.error = null;
+        const settled = await settle(async () => {
+            const client = await this.clientFactory();
+            await client.load();
+            if (epoch !== this.epoch) {
+                releaseChatClient(client, this.clientOwnership);
+                return;
+            }
+            this.client = client;
+            this.ready = true;
+            this.roomsUnsub = client.rooms.subscribe((snapshot) => {
+                this.stores.sync.applyRoomsSnapshot(snapshot, this.stores.chatParticipantsStore.currentUserId);
+            });
+            // Web-backed collections begin with no adopted room handles. Listing is
+            // the authoritative account hydration step; subscribing alone only emits
+            // that empty handle map and made embedded surfaces claim there were no
+            // conversations even while chat.vibes.dev showed the user's history.
+            await client.rooms.list();
+            const activeId = await client.rooms.getActiveId();
+            if (epoch !== this.epoch)
+                return;
+            if (activeId)
+                await this.openRoom(activeId);
+        });
+        if (epoch !== this.epoch)
+            return;
+        this.loading = false;
+        this.loadPromise = null;
+        if (!settled.ok) {
+            // A failed history read must not leave a ready-but-unusable singleton.
+            this.ready = false;
+            this.roomsUnsub?.();
+            this.roomsUnsub = null;
+            releaseChatClient(this.client, this.clientOwnership);
+            this.client = null;
+            const failure = settled.cause instanceof Error ? settled.cause : new Error(String(settled.cause));
+            this.error = failure;
+            throw failure;
+        }
+    }
+    async bindRoom(room) {
+        // Already bound to this exact room — re-binding would close + reopen the SSE
+        // stream for no reason (the churn that stacked EventSources, each logging
+        // "[chat-stream] open"). Bail early when nothing changed.
+        if (this.activeRoom?.id === room.id && this.roomUnsub)
+            return;
+        this.clearRoomSubscriptions();
+        const roomEpoch = this.roomEpoch;
+        const isCurrent = () => roomEpoch === this.roomEpoch;
+        // Switching rooms releases only this surface's leases. WebRoomsCollection
+        // caches shared handles, so directly closing the previous handle would kill
+        // other consumers (for example HQ Inbox) still watching that same room.
+        if (this.activeRoom && this.activeRoom.id !== room.id) {
+            // Room→room switch: the realtime store is a singleton with no per-room
+            // key, and the old room's typing-expiry timers died with its closed
+            // stream — so drop its stale typers/online dots before adopting the new
+            // room, or they linger in the new room's indicator/sidebar.
+            this.stores.sync.resetRoomRealtimeState();
+        }
+        this.activeRoom = room;
+        this.stores.sync.syncRoom(room.data, this.stores.chatParticipantsStore.currentUserId);
+        // Acquire a leased realtime subscription FIRST — before the awaited
+        // messages.list()/participants.list() below. For the cross-origin casework
+        // embed those are remote fetches to chat.vibes.dev; if either stalls or
+        // throws we must not abort before room.subscribe() (the call that opens the
+        // EventSource). Subscribing up front makes live SSE delivery independent of
+        // history/participant hydration. Generation runs synchronously inside the
+        // POST and the reply is delivered ONLY over this SSE, so it must be open.
+        // The catch below releases every partial subscription if any hydration or
+        // later binding fails, so an errored bind cannot strand an unleased stream.
+        this.roomUnsub = room.subscribe((next) => this.stores.sync.syncRoom(next, this.stores.chatParticipantsStore.currentUserId));
+        try {
+            // Subscribe before awaiting history: a turn sent with the room's creation
+            // (startConversation) already sits in the room's window, and it must render
+            // now rather than after the history and participant reads resolve.
+            this.messagesUnsub = room.messages.subscribe((messages) => {
+                // During streaming, preserve the optimistic in-memory content for the streaming message.
+                if (this.streamingAssistantId) {
+                    const optimistic = this.stores.chatMessagesStore.data.get(this.streamingAssistantId);
+                    const incoming = messages.find((message) => message.id === this.streamingAssistantId);
+                    // Skip the full roomRefs identity replacement when the array differs
+                    // from current state ONLY in the streaming message's content — ids,
+                    // length, and statuses are all equal. syncMessageChunk is already
+                    // mutating the streaming message's content in place, so replacing the
+                    // whole array would re-render every row on every chunk for nothing.
+                    // We use a conservative check (ids + length + status equality) so
+                    // that any structural change (new message, deletion, status change on
+                    // a non-streaming message) still falls through to a full sync.
+                    const currentIds = this.stores.chatMessagesStore.roomRefs.get(room.id) ?? [];
+                    // Multi-agent fan-out (select-responders) can put 2+ assistant rows in
+                    // 'streaming' at once. The single-baton fast path below applies growth to
+                    // ONLY `streamingAssistantId`, so any OTHER streaming row would freeze at
+                    // its placeholder and snap to full text on its terminal frame. The fast
+                    // path is therefore valid ONLY when the sole streaming row IS the baton:
+                    //   - 0 streaming rows → nothing growing, fast path is a safe no-op;
+                    //   - exactly 1 streaming row AND it's `streamingAssistantId` → the
+                    //     classic single-agent case, applied byte-for-byte;
+                    //   - anything else (2+ streaming, OR 1 streaming that is a NON-baton
+                    //     sibling after the baton finished) → fall through to full syncMessages,
+                    //     which applies EVERY row's server content so all fan-out replies stream.
+                    const streamingRowCount = messages.reduce((n, m) => n + (m.status === 'streaming' ? 1 : 0), 0);
+                    const soleStreamingIsBaton = streamingRowCount === 0 ||
+                        (streamingRowCount === 1 &&
+                            messages.some((m) => m.status === 'streaming' && m.id === this.streamingAssistantId));
+                    // Status equality is required for EVERY row, including the streaming
+                    // one: the check never compares content (syncMessageChunk owns that),
+                    // and the streaming row's terminal flip (streaming → sent) must fall
+                    // through to a full sync immediately — it can arrive while
+                    // streamingAssistantId is still set, and skipping it would leave a
+                    // stale "streaming" badge until some later emission.
+                    const onlyContentDiffers = soleStreamingIsBaton &&
+                        messages.length === currentIds.length &&
+                        messages.every((msg, i) => msg.id === currentIds[i] && msg.status === this.stores.chatMessagesStore.data.get(msg.id)?.status);
+                    if (onlyContentDiffers) {
+                        // The poll delivers growing `chat.message` frames where ONLY the
+                        // streaming row's content changes (status stays 'streaming'). Apply
+                        // the server's content here so streaming renders LIVE cross-isolate:
+                        // the in-isolate `chat.chunk` path is best-effort/same-isolate-only
+                        // (the whole reason the DB poll exists), so in production this poll
+                        // frame is the only growth the client ever sees. Without this the row
+                        // shows typing dots for the whole turn then snaps to the full reply on
+                        // the terminal `sent` frame — the "one lump" symptom. Keep the
+                        // regression guard for when the backend is briefly behind the
+                        // in-memory chunk stream.
+                        if (optimistic && incoming) {
+                            const inLen = (incoming.content ?? '').length;
+                            const optLen = (optimistic.content ?? '').length;
+                            // Content regression guard ONLY: if the snapshot's content trails
+                            // the optimistic in-isolate chunk stream, keep the longer optimistic
+                            // content. Metadata (ordered `segments` + `toolCalls`) is
+                            // SERVER-authoritative and grows monotonically across the turn — the
+                            // client never builds it locally — so ALWAYS carry the incoming
+                            // metadata when present, INDEPENDENT of content length. This is what
+                            // makes a tool widget appear the INSTANT a tool-call snapshot lands:
+                            // a tool-only step keeps content flat (inLen === optLen), and the old
+                            // code applied nothing in that case, so the pending tool segment was
+                            // dropped until a later text-growing or terminal frame. Now the
+                            // pending card draws immediately and reconciles pending → complete
+                            // as the result snapshot arrives.
+                            const nextContent = inLen >= optLen ? (incoming.content ?? optimistic.content) : optimistic.content;
+                            this.stores.chatMessagesStore.data.set(this.streamingAssistantId, {
+                                ...optimistic,
+                                content: nextContent,
+                                metadata: mapUnifiedMessageToLegacyMessage(incoming).metadata ?? optimistic.metadata
+                            });
+                        }
+                    }
+                    else {
+                        this.stores.sync.syncMessages(room.id, messages);
+                        if (optimistic &&
+                            incoming &&
+                            (incoming.content ?? '').length < (optimistic.content ?? '').length) {
+                            this.stores.chatMessagesStore.data.set(this.streamingAssistantId, optimistic);
+                        }
+                        // A full sync rebuilds roomRefs from the SERVER list, which never
+                        // contains our client-only assistant skeleton. If the real
+                        // assistant row hasn't arrived yet (placeholder still pending and
+                        // still the streaming id), re-append it so the typing indicator
+                        // doesn't vanish between the user-echo sync and the first chunk.
+                        this.preserveAssistantPlaceholder(room.id, messages);
+                    }
+                }
+                else {
+                    this.stores.sync.syncMessages(room.id, messages);
+                    this.preserveAssistantPlaceholder(room.id, messages);
+                }
+            });
+            const loadedMessages = await room.messages.list({ limit: Number.MAX_SAFE_INTEGER });
+            if (!isCurrent())
+                return;
+            this.stores.sync.syncMessages(room.id, loadedMessages);
+            // Refresh-resilience: if the history load brought back an assistant message
+            // that is still `streaming` (a turn in flight when the page was reloaded /
+            // navigated to), adopt it as the streaming baton NOW. Otherwise
+            // streamingAssistantId stays null and the FIRST incoming live frame would
+            // take the full-resync `else` branch (a momentary re-render of every row);
+            // worse, a tool-only snapshot wouldn't merge in place. Re-deriving here means
+            // the very next snapshot reconciles onto the existing in-flight row (content +
+            // ordered segments + tool widgets) seamlessly — a refresh looks like nothing
+            // happened.
+            const inFlight = [...loadedMessages]
+                .reverse()
+                .find((m) => m.role === 'assistant' && m.status === 'streaming');
+            this.streamingAssistantId = inFlight?.id ?? null;
+            const participants = await room.participants.list();
+            if (!isCurrent())
+                return;
+            this.stores.sync.syncParticipants(room.id, participants);
+            this.participantsUnsub = room.participants.subscribe((participants) => this.stores.sync.syncParticipants(room.id, participants));
+            this.eventsUnsub = room.onEvent((event) => this.stores.sync.handleChatRunEvent(room, event, this.stores.chatMessagesStore, {
+                getStreamingId: () => this.streamingAssistantId,
+                setStreamingId: (id) => (this.streamingAssistantId = id),
+                getPendingPlaceholderId: () => this.pendingAssistantPlaceholderId,
+                setPendingPlaceholderId: (id) => (this.pendingAssistantPlaceholderId = id)
+            }));
+            // Web approval transport: a paused server run surfaces here. The handler
+            // resolves only when the user decides via the approval bar; WebChatRoom then
+            // POSTs the decision. A new pending request supersedes any prior unresolved
+            // one (deny it so its run fails closed rather than hanging).
+            this.approvalUnsub = room.onApprovalRequest((request, signal) => new Promise((resolve) => {
+                if (this.pendingApproval) {
+                    this.pendingApproval.resolve({
+                        approved: false,
+                        reason: 'Superseded by a newer approval'
+                    });
+                }
+                const withdraw = () => {
+                    if (this.pendingApproval?.request.requestId === request.requestId) {
+                        this.pendingApproval = null;
+                    }
+                    resolve({ approved: false, reason: 'Approval request withdrawn' });
+                };
+                if (signal?.aborted) {
+                    withdraw();
+                    return;
+                }
+                signal?.addEventListener('abort', withdraw, { once: true });
+                this.pendingApproval = { request, resolve: (decision) => {
+                        signal?.removeEventListener('abort', withdraw);
+                        resolve(decision);
+                    } };
+            }));
+        }
+        catch (error) {
+            if (isCurrent()) {
+                this.clearRoomSubscriptions();
+                if (this.activeRoom === room) {
+                    this.activeRoom = null;
+                    this.stores.sync.clearActiveRoomState();
+                }
+            }
+            throw error;
+        }
+    }
+    /** Settle the pending approval from the bar (approve/deny, or workspace from/always). */
+    resolveApproval(approved, reason, remember, workspaceAccessChoice) {
+        const pending = this.pendingApproval;
+        if (!pending)
+            return;
+        this.pendingApproval = null;
+        const decision = { approved };
+        if (reason)
+            decision.reason = reason;
+        if (remember)
+            decision.remember = remember;
+        if (workspaceAccessChoice)
+            decision.workspaceAccessChoice = workspaceAccessChoice;
+        pending.resolve(decision);
+    }
+    /**
+     * Re-append the optimistic assistant skeleton after a full {@link syncMessages}
+     * if it's still pending. A full sync rebuilds `roomRefs` from the server's
+     * message list, which never includes our client-only placeholder; without
+     * this, the typing indicator flickers out between the optimistic user echo
+     * and the first real assistant chunk. Once the real assistant row arrives,
+     * `handleChatRunEvent` retires the placeholder (clears the pending id) so the
+     * server list already covers it and this becomes a no-op.
+     */
+    preserveAssistantPlaceholder(roomId, serverMessages) {
+        const placeholderId = this.pendingAssistantPlaceholderId;
+        if (!placeholderId)
+            return;
+        // If the server already delivered the real assistant row, the placeholder
+        // is obsolete — let it stay retired (it was removed by the event handler).
+        if (serverMessages.some((m) => m.role === 'assistant'))
+            return;
+        const ids = this.stores.chatMessagesStore.roomRefs.get(roomId) ?? [];
+        if (ids.includes(placeholderId))
+            return;
+        const now = new Date().toISOString();
+        this.stores.sync.syncMessageAdd(roomId, {
+            id: placeholderId,
+            roomId,
+            role: 'assistant',
+            content: '',
+            senderType: 'agent',
+            status: 'streaming',
+            createdAt: now,
+            updatedAt: now
+        });
+    }
+    clearActiveRoom() {
+        this.clearRoomSubscriptions();
+        this.activeRoom = null;
+        this.stores.sync.clearActiveRoomState();
+    }
+    clearSubscriptions() {
+        this.roomsUnsub?.();
+        this.roomsUnsub = null;
+        this.clearRoomSubscriptions();
+    }
+    clearRoomSubscriptions() {
+        this.roomEpoch += 1;
+        this.roomUnsub?.();
+        this.messagesUnsub?.();
+        this.participantsUnsub?.();
+        this.eventsUnsub?.();
+        this.approvalUnsub?.();
+        // Deny any unresolved approval so its paused run fails closed rather than
+        // hanging when we leave the room.
+        if (this.pendingApproval) {
+            this.pendingApproval.resolve({ approved: false, reason: 'Left the room before deciding' });
+            this.pendingApproval = null;
+        }
+        this.roomUnsub = null;
+        this.messagesUnsub = null;
+        this.participantsUnsub = null;
+        this.eventsUnsub = null;
+        this.approvalUnsub = null;
+        this.streamingAssistantId = null;
+        this.pendingAssistantPlaceholderId = null;
+    }
+}
+export const runtimeChatStore = contextualChatStore('runtimeChatStore');