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

package/dist/client/consumer-session-client.js

@@ -0,0 +1,683 @@
+/**
+ * ChatClient adapter for the daemon-owned local Chat capability.
+ *
+ * The adapter intentionally speaks only the typed `chat/consumer-session`
+ * contract. It contains no socket discovery, daemon credentials, native calls,
+ * or local storage fallback.
+ */
+import { CaughtFailureSchema } from '@vibesdotdev/kernel';
+import { messageStatusSchema } from "../schemas/unified.js";
+import { CHAT_CONSUMER_SESSION_ID, CHAT_CONSUMER_SESSION_KIND } from "./consumer-session-capability.js";
+import { generateMessageId } from "./_internal/storage.js";
+import { titleFromFirstMessage } from "./room-helpers.js";
+import { ChatSessionsClient } from "./sessions.js";
+const POLL_INTERVAL_MS = 70;
+/**
+ * Consumer-session message window — in-memory message store for one room.
+ *
+ * Mirrors the cloud `WebChatRoomCache`: the window holds pages fetched through
+ * `listMessages` (never the whole history), in server order. Kept deliberately
+ * stateless w.r.t. transport — the caller passes fetched pages in.
+ */
+class ConsumerSessionMessageCache {
+    messagesById = new Map();
+    order = [];
+    subscribers = new Set();
+    historyLoaded = false;
+    isHistoryLoaded() {
+        return this.historyLoaded;
+    }
+    upsert(message) {
+        if (!this.messagesById.has(message.id))
+            this.order.push(message.id);
+        this.messagesById.set(message.id, message);
+        this.notify();
+    }
+    upsertMany(messages) {
+        for (const message of messages) {
+            if (!this.messagesById.has(message.id))
+                this.order.push(message.id);
+            this.messagesById.set(message.id, message);
+        }
+        this.notify();
+    }
+    /** Merge an older page ahead of the window, preserving server order. */
+    prependMany(messages) {
+        const fresh = messages.filter((message) => !this.messagesById.has(message.id));
+        for (const message of fresh)
+            this.messagesById.set(message.id, message);
+        this.order = [...fresh.map((message) => message.id), ...this.order];
+        this.notify();
+    }
+    remove(id) {
+        const had = this.messagesById.delete(id);
+        if (had) {
+            this.order = this.order.filter((entry) => entry !== id);
+            this.notify();
+        }
+        return had;
+    }
+    clear() {
+        this.messagesById.clear();
+        this.order = [];
+        this.historyLoaded = false;
+        this.notify();
+    }
+    list() {
+        return this.order.map((id) => this.messagesById.get(id)).filter((message) => message !== undefined);
+    }
+    get(id) {
+        return this.messagesById.get(id) ?? null;
+    }
+    subscribe(cb) {
+        this.subscribers.add(cb);
+        cb(this.list());
+        return () => this.subscribers.delete(cb);
+    }
+    /** Load the initial tail page once; later pages merge through upsert/prepend. */
+    async ensureHistoryLoaded(fetchInitial) {
+        if (this.historyLoaded)
+            return;
+        const page = await fetchInitial();
+        // History precedes anything the window already holds (a turn sent or
+        // polled before the first page landed is newer than that page).
+        const pageIds = new Set(page.messages.map((message) => message.id));
+        for (const message of page.messages)
+            this.messagesById.set(message.id, message);
+        this.order = [...pageIds, ...this.order.filter((id) => !pageIds.has(id))];
+        this.historyLoaded = true;
+        this.notify();
+    }
+    dispose() {
+        this.subscribers.clear();
+    }
+    notify() {
+        const snapshot = this.list();
+        for (const cb of this.subscribers)
+            cb(snapshot);
+    }
+}
+export async function createConsumerSessionChatClient(runtime) {
+    const capability = await runtime
+        .query(CHAT_CONSUMER_SESSION_KIND)
+        .withId(CHAT_CONSUMER_SESSION_ID)
+        .resolve();
+    const client = new ConsumerSessionChatClient(capability, runtime);
+    await client.load();
+    return client;
+}
+export class ConsumerSessionChatClient {
+    capability;
+    runtime;
+    loading = false;
+    ready = false;
+    error = null;
+    rooms;
+    sessions = new ChatSessionsClient(this);
+    folders;
+    search;
+    snapshot = { rooms: {}, activeRoomId: null };
+    roomHandles = new Map();
+    roomSubscribers = new Set();
+    constructor(capability, runtime) {
+        this.capability = capability;
+        this.runtime = runtime;
+        this.rooms = new ConsumerSessionRooms(this);
+        this.folders = {
+            list: () => this.capability.listFolders(),
+            create: (input) => this.capability.createFolder(input),
+            moveRooms: (input) => this.capability.moveRooms(input),
+            update: (id, input) => this.capability.updateFolder(id, input),
+            remove: (id) => this.capability.removeFolder(id),
+            moveRoom: (input) => this.capability.moveRoom(input)
+        };
+        this.search = {
+            messages: ({ signal: _signal, ...input }) => this.capability.searchMessages(input)
+        };
+    }
+    /** The owning runtime's lifecycle port (bounded waits and delays). */
+    get lifecycle() {
+        return this.runtime.lifecycle;
+    }
+    async load() {
+        if (this.ready)
+            return;
+        this.loading = true;
+        this.error = null;
+        try {
+            await this.adoptSnapshot(await this.capability.snapshot());
+            this.ready = true;
+        }
+        catch (cause) {
+            this.error = cause instanceof Error ? cause : new Error(String(cause), { cause });
+            throw this.error;
+        }
+        finally {
+            this.loading = false;
+        }
+    }
+    getComposerOptions() {
+        return this.capability.getComposerOptions();
+    }
+    listBackgroundProcesses(sessionId) {
+        return this.capability.listBackgroundProcesses(sessionId);
+    }
+    stopBackgroundProcess(sessionId, procId, signal) {
+        return this.capability.stopBackgroundProcess(sessionId, procId, signal);
+    }
+    listRoomBackgroundProcesses(roomId) {
+        return this.capability.listRoomBackgroundProcesses(roomId);
+    }
+    async startConversation(input) {
+        const room = await this.rooms.create({
+            ...input.room,
+            title: !input.room?.title || input.room.title === 'New Conversation'
+                ? titleFromFirstMessage(input.message.content)
+                : input.room.title
+        });
+        return { room, completion: room.send(input.message) };
+    }
+    dispose() {
+        for (const room of this.roomHandles.values())
+            room.dispose();
+        this.roomHandles.clear();
+        this.roomSubscribers.clear();
+        this.ready = false;
+    }
+    currentSnapshot() {
+        return this.snapshot;
+    }
+    /**
+     * Adopt room metadata (summaries flow here from every method result).
+     * Message content lives in each handle's cache and is never touched here.
+     */
+    room(data) {
+        const existing = this.roomHandles.get(data.id);
+        if (existing) {
+            existing.adopt(data);
+            return existing;
+        }
+        const room = new ConsumerSessionChatRoom(data, this);
+        this.roomHandles.set(data.id, room);
+        return room;
+    }
+    /** Adopted handle for a known room, if one exists. Never fetches. */
+    roomHandle(id) {
+        return this.roomHandles.get(id) ?? null;
+    }
+    async refresh() {
+        await this.syncSummaries();
+        await Promise.all([...this.roomHandles.values()]
+            .filter((handle) => handle.isHistoryLoaded())
+            .map(async (handle) => handle.refreshTail()));
+        await this.notifyRooms();
+    }
+    /** Re-pull summaries only. Message windows merge fresh tails through `refresh`, never here. */
+    async syncSummaries() {
+        await this.adoptSnapshot(await this.capability.snapshot());
+    }
+    async adoptSnapshot(snapshot) {
+        this.snapshot = snapshot;
+        for (const summary of Object.values(snapshot.rooms)) {
+            const existing = this.roomHandles.get(summary.id);
+            if (existing) {
+                existing.adopt(summary);
+            }
+            else {
+                this.roomHandles.set(summary.id, new ConsumerSessionChatRoom(summary, this));
+            }
+        }
+        for (const [id, room] of this.roomHandles) {
+            if (!snapshot.rooms[id]) {
+                room.dispose();
+                this.roomHandles.delete(id);
+            }
+        }
+        await this.notifyRooms();
+    }
+    /** Adopt the authoritative active id after `setActiveRoom` without re-fetching any room content. */
+    async adoptActiveRoomId(activeRoomId) {
+        this.snapshot = { ...this.snapshot, activeRoomId };
+        await this.notifyRooms();
+    }
+    roomsSnapshot() {
+        const rooms = {};
+        for (const [id, handle] of this.roomHandles)
+            rooms[id] = handle.data;
+        return { rooms, activeRoomId: this.snapshot.activeRoomId };
+    }
+    async notifyRooms() {
+        const snapshot = this.roomsSnapshot();
+        for (const subscriber of this.roomSubscribers)
+            subscriber(snapshot);
+    }
+    subscribeRooms(subscriber) {
+        this.roomSubscribers.add(subscriber);
+        subscriber(this.roomsSnapshot());
+        return () => this.roomSubscribers.delete(subscriber);
+    }
+    async saveRoom(roomId, patch) {
+        const data = await this.capability.saveRoom(roomId, patch);
+        this.room(data);
+        await this.syncSummaries();
+        return data;
+    }
+    async updateRoomSettings(roomId, patch) {
+        const data = await this.capability.updateRoomSettings(roomId, patch);
+        this.room(data);
+        await this.syncSummaries();
+        return data;
+    }
+    async clearRoom(roomId) {
+        const data = await this.capability.clearRoom(roomId);
+        this.roomHandle(roomId)?.clearMessageCache();
+        this.room(data);
+        await this.syncSummaries();
+        return data;
+    }
+    capabilityRef() {
+        return this.capability;
+    }
+}
+class ConsumerSessionRooms {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async list() {
+        await this.client.syncSummaries();
+        return Object.values(this.client.currentSnapshot().rooms)
+            .sort((left, right) => right.lastMessageAt.localeCompare(left.lastMessageAt))
+            .map((summary) => this.client.roomHandle(summary.id));
+    }
+    async get(id, options = {}) {
+        if (options.refresh)
+            await this.client.syncSummaries();
+        if (!this.client.currentSnapshot().rooms[id])
+            return null;
+        return this.client.roomHandle(id);
+    }
+    async create(input) {
+        const room = this.client.room(await this.client.capabilityRef().createRoom(input));
+        await this.client.syncSummaries();
+        return room;
+    }
+    async createOrGet(input) {
+        const result = await this.client.capabilityRef().createOrGetRoom(input);
+        const room = this.client.room(result.room);
+        await this.client.syncSummaries();
+        return { room, created: result.created };
+    }
+    async remove(id) {
+        const removed = await this.client.capabilityRef().removeRoom(id);
+        await this.client.syncSummaries();
+        return removed;
+    }
+    async fork(sourceRoomId, upToMessageId) {
+        const room = this.client.room(await this.client.capabilityRef().forkRoom(sourceRoomId, upToMessageId));
+        await this.client.syncSummaries();
+        return room;
+    }
+    getActiveId() {
+        return Promise.resolve(this.client.currentSnapshot().activeRoomId);
+    }
+    async setActiveId(id) {
+        const { activeRoomId } = await this.client.capabilityRef().setActiveRoom(id);
+        await this.client.adoptActiveRoomId(activeRoomId);
+    }
+    subscribe(cb) {
+        return this.client.subscribeRooms(cb);
+    }
+}
+class ConsumerSessionChatRoom {
+    data;
+    client;
+    roomSubscribers = new Set();
+    eventSubscribers = new Set();
+    /** A failed approval surface, per run, for that run's poll loop to rethrow. */
+    approvalFailures = new Map();
+    participantSubscribers = new Set();
+    approvalHandler = null;
+    activeRunId = null;
+    messageCache = new ConsumerSessionMessageCache();
+    messages;
+    participants;
+    constructor(data, client) {
+        this.data = data;
+        this.client = client;
+        this.messages = this.createMessages();
+        this.participants = this.createParticipants();
+    }
+    get id() {
+        return this.data.id;
+    }
+    readDurableTurnReceipt(messageId) {
+        return this.client.capabilityRef().readTurnReceipt(this.id, messageId);
+    }
+    /**
+     * Adopt room metadata. Message content lives in the cache and is never
+     * touched here — pages and poll deltas merge through it instead.
+     */
+    adopt(data) {
+        this.data = data;
+        for (const subscriber of this.roomSubscribers)
+            subscriber(data);
+        const participants = this.participantList();
+        for (const subscriber of this.participantSubscribers)
+            subscriber(participants);
+    }
+    isHistoryLoaded() {
+        return this.messageCache.isHistoryLoaded();
+    }
+    /** Merge the latest tail page (refresh path for history-loaded rooms). */
+    async refreshTail() {
+        const page = await this.client.capabilityRef().listMessages(this.id);
+        this.messageCache.upsertMany(page.messages);
+    }
+    clearMessageCache() {
+        this.messageCache.clear();
+    }
+    save(patch) {
+        return this.client.saveRoom(this.id, patch).then((data) => this.adopt(data));
+    }
+    updateSettings(patch) {
+        return this.client.updateRoomSettings(this.id, patch).then((data) => this.adopt(data));
+    }
+    clear() {
+        return this.client.clearRoom(this.id).then((data) => this.adopt(data));
+    }
+    remove() {
+        return this.client.rooms.remove(this.id).then(() => undefined);
+    }
+    async send(input) {
+        const iterator = this.run(input);
+        while (true) {
+            const next = await iterator.next();
+            if (next.done)
+                return next.value;
+            for (const subscriber of this.eventSubscribers)
+                subscriber(next.value);
+        }
+    }
+    async *run(input) {
+        const { signal, ...wireInput } = input;
+        // The user's turn shows the instant it is sent, like the web transport's
+        // optimistic row: it is keyed by the idempotency key the daemon adopts as
+        // its user message id, so the daemon's row replaces it in place.
+        const userMessageId = wireInput.idempotencyKey ?? generateMessageId();
+        const echo = {
+            id: userMessageId,
+            roomId: this.id,
+            senderType: 'user',
+            role: 'user',
+            content: wireInput.content,
+            attachments: wireInput.attachments,
+            status: 'sending',
+            createdAt: new Date().toISOString()
+        };
+        this.messageCache.upsert(echo);
+        let runId;
+        try {
+            ({ runId } = await this.client
+                .capabilityRef()
+                .beginRun(this.id, { ...wireInput, idempotencyKey: userMessageId }));
+        }
+        catch (cause) {
+            this.messageCache.upsert({ ...echo, status: 'failed' });
+            throw cause;
+        }
+        this.activeRunId = runId;
+        let cursor = 0;
+        let handledApproval = null;
+        let approvalController = null;
+        const abort = () => {
+            void this.client.capabilityRef().cancelRun(runId);
+        };
+        signal?.addEventListener('abort', abort, { once: true });
+        try {
+            while (true) {
+                const approvalFailure = this.approvalFailures.get(runId);
+                if (approvalFailure) {
+                    await this.client.capabilityRef().cancelRun(runId);
+                    throw approvalFailure;
+                }
+                const poll = await this.client.capabilityRef().pollRun(runId, cursor);
+                cursor = poll.cursor;
+                this.client.room(poll.room);
+                this.messageCache.upsertMany(poll.messages);
+                const snapshotMessages = new Map(poll.messages.map((message) => [message.id, message]));
+                // SAFETY: the daemon's pollRun forwards only the ChatRunEvents its own room
+                // emitted for this run; the wire schema checks each carries a `type`.
+                for (const event of poll.events) {
+                    const snapshot = event.type === 'chunk' ? snapshotMessages.get(event.messageId) : undefined;
+                    yield event.type === 'chunk' && snapshot
+                        ? { ...event, snapshotContent: snapshot.content } : event;
+                }
+                if (!poll.approval || poll.approval.requestId !== handledApproval) {
+                    approvalController?.abort();
+                }
+                if (poll.approval && handledApproval !== poll.approval.requestId) {
+                    handledApproval = poll.approval.requestId;
+                    const request = poll.approval;
+                    const controller = new AbortController();
+                    approvalController = controller;
+                    // Human interaction must not suspend runtime observation. A withdrawn
+                    // request loses its authority even if its dialog resolves later.
+                    void Promise.resolve().then(async () => {
+                        const decision = this.approvalHandler
+                            ? await this.approvalHandler(request, controller.signal)
+                            : { approved: false, reason: 'No approval surface is attached' };
+                        if (!controller.signal.aborted) {
+                            await this.client.capabilityRef().decideApproval(runId, request.requestId, decision);
+                        }
+                    }).catch((error) => {
+                        this.recordApprovalFailure(runId, controller.signal, CaughtFailureSchema.parse(error));
+                    });
+                }
+                if (poll.status === 'completed' && poll.result) {
+                    await this.client.refresh();
+                    return poll.result;
+                }
+                if (poll.status === 'cancelled') {
+                    if (poll.result)
+                        return poll.result;
+                    throw new Error(poll.error ?? 'Generation cancelled');
+                }
+                if (poll.status === 'failed') {
+                    throw new Error(poll.error ?? 'Local agent generation failed');
+                }
+                // Unsignalled on purpose: an abort only sends cancelRun, and polling continues
+                // until the run reports its cancelled state and result.
+                await this.client.lifecycle.delay(POLL_INTERVAL_MS);
+            }
+        }
+        finally {
+            approvalController?.abort();
+            signal?.removeEventListener('abort', abort);
+            this.approvalFailures.delete(runId);
+            if (this.activeRunId === runId)
+                this.activeRunId = null;
+        }
+    }
+    /** A withdrawn request lost its authority, so its surface's failure no longer ends the run. */
+    recordApprovalFailure(runId, request, failure) {
+        if (!request.aborted)
+            this.approvalFailures.set(runId, failure);
+    }
+    async cancel() {
+        const runId = this.activeRunId;
+        if (runId)
+            await this.client.capabilityRef().cancelRun(runId);
+    }
+    onEvent(cb) {
+        this.eventSubscribers.add(cb);
+        return () => this.eventSubscribers.delete(cb);
+    }
+    onApprovalRequest(handler) {
+        this.approvalHandler = handler;
+        return () => {
+            if (this.approvalHandler === handler)
+                this.approvalHandler = null;
+        };
+    }
+    subscribe(cb) {
+        this.roomSubscribers.add(cb);
+        cb(this.data);
+        return () => this.roomSubscribers.delete(cb);
+    }
+    dispose() {
+        void this.cancel();
+        this.roomSubscribers.clear();
+        this.eventSubscribers.clear();
+        this.messageCache.dispose();
+        this.participantSubscribers.clear();
+        this.approvalHandler = null;
+    }
+    createMessages() {
+        return {
+            list: async (options = {}) => {
+                if (options.cursor || options.refresh) {
+                    const page = {
+                        direction: options.direction ?? 'before'
+                    };
+                    if (options.cursor)
+                        page.cursor = options.cursor;
+                    if (options.limit !== undefined)
+                        page.limit = options.limit;
+                    return this.fetchMessagePage(page);
+                }
+                await this.messageCache.ensureHistoryLoaded(() => this.client.capabilityRef().listMessages(this.id));
+                const window = this.messageCache.list();
+                const limit = options.limit ?? window.length;
+                return options.direction === 'after' ? window.slice(0, limit) : window.slice(-limit);
+            },
+            get: async (id) => {
+                const cached = this.messageCache.get(id);
+                if (cached)
+                    return cached;
+                const page = await this.client.capabilityRef().listMessages(this.id, { messageId: id });
+                const found = page.messages[0] ?? null;
+                if (found)
+                    this.messageCache.upsert(found);
+                return found;
+            },
+            create: async (input) => {
+                const messageInput = {
+                    role: input.role,
+                    content: input.content
+                };
+                if (input.id)
+                    messageInput.id = input.id;
+                if (input.senderType)
+                    messageInput.senderType = input.senderType;
+                if (input.status)
+                    messageInput.status = messageStatusSchema.parse(input.status);
+                if (input.agentId)
+                    messageInput.agentId = input.agentId;
+                if (input.userId)
+                    messageInput.userId = input.userId;
+                if (input.replyToId)
+                    messageInput.replyToId = input.replyToId;
+                if (input.metadata)
+                    messageInput.metadata = input.metadata;
+                const message = await this.client.capabilityRef().createMessage(this.id, messageInput);
+                this.messageCache.upsert(message);
+                return message;
+            },
+            update: async (id, patch) => {
+                const patchInput = {};
+                if (patch.content !== undefined)
+                    patchInput.content = patch.content;
+                if (patch.status !== undefined)
+                    patchInput.status = patch.status;
+                if (patch.cancelled !== undefined)
+                    patchInput.cancelled = patch.cancelled;
+                if (patch.streaming !== undefined)
+                    patchInput.streaming = patch.streaming;
+                if (patch.metadata !== undefined)
+                    patchInput.metadata = patch.metadata;
+                const next = await this.client.capabilityRef().updateMessage(this.id, id, patchInput);
+                if (next)
+                    this.messageCache.upsert(next);
+                return next;
+            },
+            remove: async (id) => {
+                const removed = await this.client.capabilityRef().removeMessage(this.id, id);
+                if (removed)
+                    this.messageCache.remove(id);
+                return removed;
+            },
+            clear: async () => {
+                const summary = await this.client.capabilityRef().clearMessages(this.id);
+                this.messageCache.clear();
+                this.adopt(summary);
+            },
+            listToolCalls: async (messageId, page) => {
+                return this.client.capabilityRef().listMessageToolCalls(this.id, messageId, page);
+            },
+            subscribe: (cb) => this.messageCache.subscribe(cb)
+        };
+    }
+    /** Fetch one page through the capability and merge it into the window. */
+    async fetchMessagePage(page) {
+        const result = await this.client.capabilityRef().listMessages(this.id, page);
+        if (page.direction === 'after' || !page.cursor) {
+            this.messageCache.upsertMany(result.messages);
+        }
+        else {
+            this.messageCache.prependMany(result.messages);
+        }
+        return result.messages;
+    }
+    createParticipants() {
+        return {
+            list: async () => this.participantList(),
+            get: async (key) => this.data.participants?.[key] ?? null,
+            add: async (input) => {
+                const key = `${input.type}:${input.id}`;
+                const participant = {
+                    ...input,
+                    responseStyle: input.responseStyle ?? 'auto',
+                    enabled: input.enabled ?? true
+                };
+                await this.save({
+                    participants: { ...this.data.participants, [key]: participant }
+                });
+                return participant;
+            },
+            update: async (key, patch) => {
+                const current = this.data.participants?.[key];
+                if (!current)
+                    return null;
+                const next = { ...current, ...patch };
+                await this.save({
+                    participants: { ...this.data.participants, [key]: next }
+                });
+                return next;
+            },
+            remove: async (key) => {
+                if (!this.data.participants?.[key])
+                    return false;
+                const participants = { ...this.data.participants };
+                delete participants[key];
+                await this.save({ participants });
+                return true;
+            },
+            setEnabled: async (key, enabled) => {
+                await this.participants.update(key, { enabled });
+            },
+            setResponseStyle: async (key, style) => {
+                await this.participants.update(key, { responseStyle: style });
+            },
+            subscribe: (cb) => {
+                this.participantSubscribers.add(cb);
+                cb(this.participantList());
+                return () => this.participantSubscribers.delete(cb);
+            }
+        };
+    }
+    participantList() {
+        return Object.values(this.data.participants ?? {}).sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+    }
+}
+//# sourceMappingURL=consumer-session-client.js.map