@nocobase/app-plugin-agents 0.1.0-beta.8 → 1.0.0-beta.15

package/dist/client/chat/controller.js

@@ -0,0 +1,767 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable react-refresh/only-export-components -- shared controller provider and hooks */
+import { CancelledError } from '@tanstack/react-query';
+import { isToolUIPart } from 'ai';
+import { Chat, useChat as useSDKChat } from '@ai-sdk/react';
+import { createContext, useContext, useEffect, useLayoutEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
+import { useApiClient } from '@nocobase/app-client';
+import { ChatApi } from './api.js';
+import { chatIsRunning } from './feedback.js';
+import { ChatSubmissions } from './submissions.js';
+import { agentsQueryClient } from '../query.js';
+import { chatKeys } from './keys.js';
+import { EMPTY_MESSAGES, messagesReducer, mergeUIMessages, } from './message-model.js';
+function deferred() {
+    let resolve, reject;
+    const promise = new Promise((yes, no) => {
+        resolve = yes;
+        reject = no;
+    });
+    return { promise, resolve, reject };
+}
+/** Application coordination around one SDK Chat per conversation, shared by every surface. */
+export class ChatController {
+    api;
+    submissions;
+    chats = new Map();
+    histories = new Map();
+    loads = new Map();
+    refreshAgain = new Set();
+    resumed = new Set();
+    resuming = new Map();
+    recoveryErrors = new Map();
+    admissions = new Map();
+    watches = new Map();
+    messageVersions = new Map();
+    revisionQueue = new Map();
+    deferredReads = new Map();
+    completionReads = new Set();
+    stopRequests = new Set();
+    approvalRequests = new Set();
+    listeners = new Set();
+    revision = 0;
+    disposed = false;
+    generation = 0;
+    detailVersions = new Map();
+    commandVersions = new Map();
+    constructor(api) {
+        this.api = api;
+        this.submissions = new ChatSubmissions({
+            createConversation: (input) => api.createConversation(input),
+            messages: (id, query) => api.messages(id, query),
+            sendMessage: (id, input) => this.command(id, () => this.sendInput(id, input), (result) => result.conversation),
+        }, (detail, _record, created) => {
+            if (created)
+                this.remember(detail);
+        }, undefined, (id, message) => this.dispatch(id, { type: 'confirmed', message }));
+        this.submissions.subscribe(() => this.publish());
+    }
+    chat(id) {
+        let chat = this.chats.get(id);
+        if (!chat) {
+            chat = new Chat({
+                id,
+                transport: this.api.transport(id, (clientId) => {
+                    const admission = this.admissions.get(id);
+                    if (!this.disposed && admission?.clientId === clientId)
+                        admission.gate.resolve();
+                }),
+                onFinish: () => {
+                    if (!this.disposed && this.chats.get(id) === chat)
+                        this.scheduleRefresh(id);
+                },
+                onError: () => {
+                    if (this.disposed || this.chats.get(id) !== chat)
+                        return;
+                    this.scheduleRefresh(id);
+                },
+            });
+            this.chats.set(id, chat);
+        }
+        return chat;
+    }
+    renewChat(id, messages) {
+        const previous = this.chats.get(id);
+        this.chats.delete(id);
+        const chat = this.chat(id);
+        chat.messages = messages;
+        void previous?.stop();
+        this.publish();
+        return chat;
+    }
+    history(id) {
+        const current = this.histories.get(id);
+        return {
+            state: {
+                ...(current?.page ?? EMPTY_MESSAGES),
+                items: this.chat(id).messages,
+                pending: [],
+            },
+            error: current?.error,
+            loadingOlder: current?.loadingOlder ?? false,
+            loadedThrough: current?.loadedThrough ?? 0,
+        };
+    }
+    historyMeta(id) {
+        const previous = this.histories.get(id);
+        if (previous)
+            return previous;
+        const { items: _items, pending: _pending, ...page } = EMPTY_MESSAGES;
+        const created = { page, loadingOlder: false, loadedThrough: 0 };
+        this.histories.set(id, created);
+        return created;
+    }
+    dispatch(id, action) {
+        if (this.disposed)
+            return;
+        if (action.type === 'discard') {
+            const record = this.submissions
+                .snapshot()
+                .find((item) => item.clientId === action.clientId);
+            if (record && ['notSubmitted', 'rejected'].includes(record.status)) {
+                const chat = this.chat(id);
+                chat.messages = chat.messages.filter((message) => message.id !== action.clientId ||
+                    message.metadata?.seq !== undefined);
+                chat.clearError();
+            }
+            this.submissions.editRejected(action.clientId);
+            return;
+        }
+        const current = this.historyMeta(id);
+        const before = this.history(id).state;
+        const next = messagesReducer(before, action);
+        const chat = this.chat(id);
+        const streaming = chat.status === 'submitted' || chat.status === 'streaming';
+        const activeId = streaming && chat.messages.at(-1)?.role === 'assistant'
+            ? chat.messages.at(-1).id
+            : undefined;
+        if (action.type === 'page' || action.type === 'confirmed') {
+            const incoming = action.type === 'page' ? action.page.items : [action.message];
+            const lastUser = Math.max(0, ...[...chat.messages, ...incoming]
+                .filter((message) => message.role === 'user')
+                .map((message) => message.metadata?.seq ?? 0));
+            const batch = incoming.filter((message) => {
+                const allowed = !streaming ||
+                    Boolean(activeId) ||
+                    message.role !== 'assistant' ||
+                    (message.metadata?.seq ?? Infinity) <= lastUser;
+                if (!allowed) {
+                    const pending = this.deferredReads.get(id) ?? new Set();
+                    pending.add(message.id);
+                    this.deferredReads.set(id, pending);
+                }
+                return allowed;
+            });
+            chat.messages = mergeUIMessages(chat.messages, batch, activeId);
+        }
+        const { items: _items, pending: _pending, ...page } = next;
+        this.histories.set(id, {
+            ...current,
+            page,
+            loadedThrough: action.type === 'page' && !action.older && !action.reread
+                ? Math.max(current.loadedThrough, action.page.nextAfter ?? action.page.lastSeq)
+                : current.loadedThrough,
+        });
+        this.publish();
+    }
+    async loadHistory(id, older = false, fresh = false) {
+        if (this.disposed)
+            return;
+        const pending = this.loads.get(id);
+        if (pending) {
+            if (fresh)
+                this.refreshAgain.add(id);
+            return pending;
+        }
+        const active = this.lifetime();
+        const initial = this.history(id);
+        if (older && !initial.state.olderToken)
+            return;
+        this.historyMeta(id).loadingOlder = older;
+        this.publish();
+        const task = (async () => {
+            try {
+                let after = initial.state.loaded ? initial.loadedThrough : undefined;
+                const seen = new Set();
+                while (active()) {
+                    const page = await this.api.messages(id, older
+                        ? { pageToken: this.history(id).state.olderToken }
+                        : after === undefined
+                            ? {}
+                            : { after });
+                    if (!active())
+                        return;
+                    this.dispatch(id, { type: 'page', page, older });
+                    this.submissions.observe(id, page.items);
+                    const metadata = this.historyMeta(id);
+                    if (!older)
+                        metadata.loadedThrough = page.nextAfter ?? page.lastSeq;
+                    if (!older && page.nextAfter !== undefined) {
+                        if (seen.has(page.nextAfter))
+                            throw new Error('History pagination did not advance.');
+                        seen.add(page.nextAfter);
+                        after = page.nextAfter;
+                        continue;
+                    }
+                    if (this.refreshAgain.delete(id)) {
+                        older = false;
+                        after = this.history(id).loadedThrough;
+                        continue;
+                    }
+                    break;
+                }
+                if (active()) {
+                    const pending = [...(this.deferredReads.get(id) ?? [])];
+                    const owner = this.chat(id);
+                    if (pending.length &&
+                        owner.status !== 'submitted' &&
+                        owner.status !== 'streaming')
+                        await this.reread(id, pending);
+                    if (active())
+                        this.historyMeta(id).error = undefined;
+                }
+            }
+            catch (error) {
+                if (active())
+                    this.historyMeta(id).error = error;
+            }
+            finally {
+                if (active()) {
+                    this.historyMeta(id).loadingOlder = false;
+                    this.loads.delete(id);
+                    this.publish();
+                }
+            }
+        })();
+        this.loads.set(id, task);
+        return task;
+    }
+    async reread(id, ids) {
+        if (this.disposed)
+            return [];
+        const found = [];
+        const active = this.lifetime();
+        for (let offset = 0; offset < ids.length; offset += 100) {
+            const page = await this.api.messages(id, {
+                ids: ids.slice(offset, offset + 100).join(','),
+            });
+            if (!active())
+                return [];
+            found.push(...page.items);
+            const pending = this.deferredReads.get(id);
+            for (const message of page.items) {
+                if ((message.metadata?.revision ?? 0) >=
+                    (this.messageVersions.get(`${id}:${message.id}`) ?? 0))
+                    pending?.delete(message.id);
+            }
+            if (pending?.size === 0)
+                this.deferredReads.delete(id);
+            this.dispatch(id, { type: 'page', page, reread: true });
+            this.submissions.observe(id, page.items);
+        }
+        return found;
+    }
+    watch(id) {
+        let watch = this.watches.get(id);
+        if (!watch) {
+            const active = this.lifetime();
+            const timer = setInterval(() => {
+                if (!active() || document.visibilityState === 'hidden')
+                    return;
+                const detail = agentsQueryClient().getQueryData(chatKeys.conversation(id));
+                const current = this.watches.get(id);
+                const interval = detail?.execution?.status === 'running' ? 5000 : 30000;
+                if (Date.now() - current.last < interval)
+                    return;
+                current.last = Date.now();
+                void this.loadHistory(id, false, true);
+            }, 5000);
+            watch = { refs: 0, timer, last: Date.now() };
+            this.watches.set(id, watch);
+        }
+        watch.refs++;
+        return () => {
+            const current = this.watches.get(id);
+            if (current && --current.refs === 0) {
+                clearInterval(current.timer);
+                this.watches.delete(id);
+            }
+        };
+    }
+    reconnect() {
+        for (const id of this.watches.keys())
+            void this.resume(id);
+    }
+    messageUpdated(id, messageId, revision) {
+        const key = `${id}:${messageId}`;
+        if (((this.messageVersions.get(key) ?? -1) >= revision &&
+            !this.deferredReads.get(id)?.has(messageId)) ||
+            this.disposed)
+            return;
+        this.messageVersions.set(key, Math.max(this.messageVersions.get(key) ?? -1, revision));
+        const previous = this.revisionQueue.get(id);
+        if (previous) {
+            previous.pending.add(messageId);
+            return;
+        }
+        const queue = { pending: new Set([messageId]), task: Promise.resolve() };
+        this.revisionQueue.set(id, queue);
+        const active = this.lifetime();
+        queue.task = (async () => {
+            const attempted = new Set();
+            try {
+                while (active() && queue.pending.size) {
+                    const ids = [...queue.pending];
+                    queue.pending.clear();
+                    ids.forEach((id) => attempted.add(id));
+                    await this.reread(id, ids);
+                }
+            }
+            catch (error) {
+                if (active()) {
+                    const retry = this.deferredReads.get(id) ?? new Set();
+                    for (const messageId of [...attempted, ...queue.pending]) {
+                        retry.add(messageId);
+                    }
+                    this.deferredReads.set(id, retry);
+                    this.historyMeta(id).error = error;
+                    this.publish();
+                }
+            }
+            finally {
+                if (active())
+                    this.revisionQueue.delete(id);
+            }
+        })();
+    }
+    async sendInput(id, input) {
+        if (this.disposed)
+            throw new CancelledError({ silent: true });
+        const chat = this.chat(id);
+        if (chat.status === 'submitted' || chat.status === 'streaming')
+            throw new Error('This conversation is already receiving a response.');
+        const admitted = deferred();
+        this.admissions.set(id, { clientId: input.clientId, gate: admitted });
+        this.recoveryErrors.delete(id);
+        const active = this.lifetime();
+        const sending = chat.sendMessage({
+            id: input.clientId,
+            role: 'user',
+            metadata: {
+                conversationId: id,
+                createdAt: new Date().toISOString(),
+                revision: 0,
+                ...(input.context
+                    ? {
+                        context: {
+                            route: input.context.route,
+                            items: [],
+                            dropped: 0,
+                            ...(input.context.ui
+                                ? { ui: structuredClone(input.context.ui) }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            },
+            parts: [{ type: 'text', text: input.content }],
+        }, {
+            body: {
+                ...(input.context ? { context: input.context } : {}),
+                ...(input.attachmentIds?.length
+                    ? { attachmentIds: input.attachmentIds }
+                    : {}),
+            },
+        });
+        void sending.then(() => admitted.reject(chat.error ??
+            new Error('The response ended before input admission was confirmed.')), (error) => admitted.reject(error));
+        try {
+            await admitted.promise;
+        }
+        finally {
+            if (this.admissions.get(id)?.gate === admitted)
+                this.admissions.delete(id);
+        }
+        if (!active())
+            throw new CancelledError({ silent: true });
+        await this.loadHistory(id, false, true);
+        const conversation = await this.api.conversation(id);
+        if (!active())
+            throw new CancelledError({ silent: true });
+        const message = this.chat(id).messages.find((message) => message.role === 'user' &&
+            message.metadata?.seq !== undefined &&
+            (message.metadata?.clientId ?? message.id) === input.clientId);
+        if (!message)
+            throw new Error('Input was accepted; reconcile its saved message before sending again.');
+        return { message, conversation };
+    }
+    state(id) {
+        const chat = this.chats.get(id);
+        return chat
+            ? {
+                status: chat.status,
+                error: chat.error ?? this.recoveryErrors.get(id),
+            }
+            : undefined;
+    }
+    receive(id, known) {
+        if (this.disposed || this.resumed.has(id))
+            return;
+        const detail = known ??
+            agentsQueryClient().getQueryData(chatKeys.conversation(id));
+        if (!detail?.execution)
+            return;
+        this.resumed.add(id);
+        if (detail?.execution?.status === 'idle' ||
+            detail?.execution?.waitingApproval)
+            return;
+        void this.resume(id);
+    }
+    async resume(id) {
+        if (this.disposed)
+            return;
+        const pending = this.resuming.get(id);
+        if (pending)
+            return pending;
+        let chat = this.chat(id);
+        if (chat.status === 'submitted' || chat.status === 'streaming')
+            return;
+        const active = this.lifetime();
+        const canResume = () => active() &&
+            this.chats.get(id) === chat &&
+            chat.status !== 'submitted' &&
+            chat.status !== 'streaming';
+        const task = (async () => {
+            let interrupted;
+            try {
+                await this.loadHistory(id);
+                // A new input can begin while the recovery snapshot is still being read.
+                if (!canResume())
+                    return;
+                if (chat.error) {
+                    const previous = chat;
+                    interrupted = [...previous.messages]
+                        .reverse()
+                        .find((message) => message.role === 'assistant');
+                    // Shared recovery replays this response's full prefix. SDK disconnect state expects deltas instead.
+                    // Recreate its one shared owner using public state, never the SDK's private resumable cache.
+                    if (interrupted?.parts.some((part) => isToolUIPart(part) &&
+                        (part.state === 'input-streaming' ||
+                            part.state === 'approval-responded'))) {
+                        const saved = await this.reread(id, [interrupted.id]);
+                        if (!canResume())
+                            return;
+                        if (!saved.some((message) => message.id === interrupted.id))
+                            previous.messages = previous.messages.filter((message) => message.id !== interrupted.id);
+                    }
+                    chat = this.renewChat(id, previous.messages);
+                    if (!active())
+                        return;
+                }
+                this.recoveryErrors.delete(id);
+                chat.clearError();
+                const response = [...chat.messages]
+                    .reverse()
+                    .find((message) => message.role === 'assistant');
+                if (response)
+                    chat.messages = mergeUIMessages(chat.messages, [], response.id);
+                await chat.resumeStream();
+                if (active())
+                    await this.refresh(id);
+            }
+            catch (error) {
+                if (canResume())
+                    this.recoveryErrors.set(id, error instanceof Error
+                        ? error
+                        : new Error('Stream recovery failed.'));
+            }
+            finally {
+                if (active()) {
+                    const display = interrupted;
+                    if (display &&
+                        canResume() &&
+                        !chat.messages.some((message) => message.id === display.id))
+                        chat.messages = mergeUIMessages(chat.messages, [display]);
+                    this.resuming.delete(id);
+                    this.publish();
+                }
+            }
+        })();
+        this.resuming.set(id, task);
+        return task;
+    }
+    async approve(id, input) {
+        const active = this.lifetime();
+        if (!active())
+            throw new CancelledError({ silent: true });
+        const chat = this.chat(id);
+        if (this.approvalRequests.has(id) ||
+            chat.status === 'submitted' ||
+            chat.status === 'streaming')
+            throw new Error('This conversation is busy.');
+        this.approvalRequests.add(id);
+        this.commandVersions.set(id, (this.commandVersions.get(id) ?? 0) + 1);
+        this.nextDetailVersion(id);
+        try {
+            await agentsQueryClient().cancelQueries({
+                queryKey: chatKeys.conversation(id),
+                exact: true,
+            });
+            if (!active())
+                throw new CancelledError({ silent: true });
+            chat.messages = mergeUIMessages(chat.messages, [], input.messageId);
+            await chat.addToolApprovalResponse(input.approval);
+            if (!active())
+                throw new CancelledError({ silent: true });
+            await chat.sendMessage(undefined, { body: { approvalInput: input } });
+            if (!active())
+                return;
+            if (chat.error)
+                throw chat.error;
+            await this.refresh(id);
+        }
+        finally {
+            if (active())
+                this.approvalRequests.delete(id);
+        }
+    }
+    async finalize(id) {
+        const active = this.lifetime();
+        await this.command(id, () => this.api.finalize(id), (detail) => detail);
+        if (active())
+            await this.refresh(id);
+    }
+    async refresh(id) {
+        if (this.disposed)
+            return;
+        const active = this.lifetime(), ordered = this.detailRequest(id);
+        const detail = await this.api.conversation(id);
+        if (!active() || !ordered())
+            return;
+        await this.loadHistory(id, false, true);
+        if (!active() || !ordered())
+            return;
+        const history = this.history(id);
+        if (history.error)
+            throw history.error instanceof Error
+                ? history.error
+                : new Error('Saved history could not be read.');
+        // Same-sequence approval revisions cannot be discovered by the insertion cursor.
+        const latest = [...this.chat(id).messages]
+            .reverse()
+            .find((message) => message.role === 'assistant');
+        const revisable = [
+            ...new Set([
+                ...(this.deferredReads.get(id) ?? []),
+                ...(detail.execution?.messageId
+                    ? [detail.execution.messageId]
+                    : latest
+                        ? [latest.id]
+                        : []),
+            ]),
+        ];
+        const saved = revisable.length ? await this.reread(id, revisable) : [];
+        if (!active() || !ordered())
+            return;
+        const owner = this.chat(id), receiving = owner.messages.at(-1);
+        if (owner.status === 'streaming' &&
+            receiving?.role === 'assistant' &&
+            (detail.execution?.status === 'idle' ||
+                detail.execution?.waitingApproval) &&
+            saved.some((message) => message.id === receiving.id &&
+                message.metadata?.seq !== undefined &&
+                message.metadata?.executionId === receiving.metadata?.executionId &&
+                message.metadata.revision >= (detail.execution?.revision ?? 0))) {
+            // Durable completion can release a lost subscriber; this never calls business Stop.
+            await owner.stop();
+            if (!active() || !ordered())
+                return;
+            owner.messages = mergeUIMessages(owner.messages, saved);
+        }
+        if (!active() || !ordered())
+            return;
+        this.remember(detail);
+        const chat = this.chat(id);
+        if (detail.execution?.status === 'idle') {
+            this.recoveryErrors.delete(id);
+            if (chat.error &&
+                saved.some((message) => message.id === chat.messages.at(-1)?.id &&
+                    message.metadata?.seq !== undefined))
+                this.renewChat(id, chat.messages);
+        }
+        else if (detail.execution?.status === 'running' &&
+            !detail.execution.waitingApproval &&
+            chat.status !== 'submitted' &&
+            chat.status !== 'streaming')
+            this.recoveryErrors.set(id, new Error('Execution remains active; reconcile saved history or resume its stream.'));
+        this.publish();
+    }
+    scheduleRefresh(id) {
+        if (this.completionReads.has(id))
+            return;
+        this.completionReads.add(id);
+        queueMicrotask(() => {
+            this.completionReads.delete(id);
+            if (!this.disposed)
+                void this.refresh(id).catch(() => { });
+        });
+    }
+    observeDetail(detail) {
+        if (detail.execution?.status === 'running')
+            this.receive(detail.id, detail);
+        if (!chatIsRunning(detail)) {
+            if (this.chats.get(detail.id)?.status === 'streaming')
+                this.scheduleRefresh(detail.id);
+            this.stopRequests.delete(detail.id);
+            this.recoveryErrors.delete(detail.id);
+            this.publish();
+        }
+    }
+    isStopping(id) {
+        return this.stopRequests.has(id);
+    }
+    async stop(id) {
+        const active = this.lifetime();
+        this.stopRequests.add(id);
+        this.publish();
+        try {
+            return await this.command(id, () => this.api.stop(id), (detail) => detail);
+        }
+        catch (error) {
+            if (active()) {
+                this.stopRequests.delete(id);
+                this.publish();
+            }
+            throw error;
+        }
+    }
+    lifetime() {
+        const generation = this.generation;
+        return () => !this.disposed && this.generation === generation;
+    }
+    nextDetailVersion(id) {
+        const version = (this.detailVersions.get(id) ?? 0) + 1;
+        this.detailVersions.set(id, version);
+        return version;
+    }
+    detailRequest(id) {
+        const active = this.lifetime(), version = this.nextDetailVersion(id);
+        return () => active() && this.detailVersions.get(id) === version;
+    }
+    remember(detail) {
+        this.nextDetailVersion(detail.id);
+        this.observeDetail(detail);
+        agentsQueryClient().setQueryData(chatKeys.conversation(detail.id), detail);
+        void agentsQueryClient().invalidateQueries({ queryKey: chatKeys.lists });
+    }
+    async command(id, request, detail) {
+        const active = this.lifetime(), version = (this.commandVersions.get(id) ?? 0) + 1;
+        this.commandVersions.set(id, version);
+        this.nextDetailVersion(id);
+        await agentsQueryClient().cancelQueries({
+            queryKey: chatKeys.conversation(id),
+            exact: true,
+        });
+        if (!active())
+            throw new CancelledError({ silent: true });
+        const result = await request();
+        if (active() && this.commandVersions.get(id) === version)
+            this.remember(detail(result));
+        return result;
+    }
+    subscribe = (callback) => {
+        this.listeners.add(callback);
+        return () => this.listeners.delete(callback);
+    };
+    snapshot = () => this.revision;
+    publish() {
+        this.revision++;
+        for (const callback of this.listeners)
+            callback();
+    }
+    activate() {
+        this.disposed = false;
+    }
+    invalidate() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.generation++;
+        for (const chat of this.chats.values())
+            void chat.stop();
+        for (const admission of this.admissions.values())
+            admission.gate.reject(new CancelledError({ silent: true }));
+        for (const watch of this.watches.values())
+            clearInterval(watch.timer);
+        this.watches.clear();
+        this.messageVersions.clear();
+        this.revisionQueue.clear();
+        this.deferredReads.clear();
+        this.completionReads.clear();
+        this.admissions.clear();
+        this.loads.clear();
+        this.refreshAgain.clear();
+        this.commandVersions.clear();
+        this.stopRequests.clear();
+        this.approvalRequests.clear();
+        this.resuming.clear();
+        this.resumed.clear();
+        this.submissions.invalidate();
+        agentsQueryClient().removeQueries({ queryKey: chatKeys.all });
+    }
+    dispose() {
+        this.invalidate();
+        this.submissions.dispose();
+        this.chats.clear();
+        this.histories.clear();
+        this.listeners.clear();
+    }
+}
+const ControllerContext = createContext(null);
+export function ChatClientProvider({ children, }) {
+    const host = useApiClient();
+    const controller = useMemo(() => new ChatController(new ChatApi(host)), [host]);
+    const lifetimesRef = useRef(new Map());
+    useLayoutEffect(() => {
+        controller.activate();
+        const lifetimes = lifetimesRef.current;
+        lifetimes.set(controller, (lifetimes.get(controller) ?? 0) + 1);
+        const reconnect = () => controller.reconnect();
+        window.addEventListener('online', reconnect);
+        return () => {
+            window.removeEventListener('online', reconnect);
+            controller.invalidate();
+            lifetimes.set(controller, (lifetimes.get(controller) ?? 1) - 1);
+            queueMicrotask(() => {
+                if (lifetimes.get(controller) === 0) {
+                    controller.dispose();
+                    lifetimes.delete(controller);
+                }
+            });
+        };
+    }, [controller]);
+    return (_jsx(ControllerContext.Provider, { value: controller, children: children }));
+}
+export function useChatController() {
+    const controller = useContext(ControllerContext);
+    if (!controller)
+        throw new Error('ChatProvider is required.');
+    return controller;
+}
+export function useChatStream(id) {
+    const controller = useChatController();
+    useSDKChat({ chat: controller.chat(id ?? 'draft') });
+    useSyncExternalStore(controller.subscribe, controller.snapshot, controller.snapshot);
+    useEffect(() => {
+        if (id)
+            controller.receive(id);
+    }, [controller, id]);
+    return id ? controller.state(id) : undefined;
+}
+export function useChatStreamState(id) {
+    const controller = useChatController();
+    useSDKChat({ chat: controller.chat(id ?? 'draft') });
+    useSyncExternalStore(controller.subscribe, controller.snapshot, controller.snapshot);
+    return id ? controller.state(id) : undefined;
+}
+//# sourceMappingURL=controller.js.map