@hachej/boring-ui-kit 0.4.19 → 0.4.20

package/dist/shared-chat/index.d.ts

@@ -33,6 +33,8 @@ export declare function createSharedChat(source: ChannelSource, options: {
     loadEarlier: () => Promise<void>;
     connect: () => Promise<void>;
     send: (_whenBusy?: ChatAttempt["whenBusy"], input?: ChatSendInput) => Promise<ChannelMessage | undefined>;
+    /** Answers an agent's question with one of its choices (or any text): a reply to the question, leaving the composer and its reply as they are. */
+    answer: (question: ChannelMessage, text: string) => Promise<ChannelMessage | undefined>;
     reconcile: () => Promise<void>;
     retrySameRequest: () => Promise<void>;
     stop: () => Promise<never>;
@@ -48,5 +50,7 @@ export declare function memberMention(member: Member): string;
 export { createFakeChannelSource } from './fake.js';
 export type { FakeChannelSeed } from './fake.js';
 export { createChannelSocket } from './socket.js';
+export { createRoomSource } from './room.js';
+export type { RoomSource, RoomSourceOptions, RoomWords } from './room.js';
 export type { ChannelSocketOptions, ChannelSocketSource } from './socket.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/shared-chat/index.js

@@ -143,6 +143,41 @@ export function createSharedChat(source, options) {
             reconnect = refresh().then(replay).catch(error => publish({ connection: { kind: 'error', error } })).finally(() => { reconnect = undefined; });
         }
     };
+    /** One message into the thread. `answering` replies to a question without touching the composer's reply, files or draft. */
+    const post = async (input, answering) => {
+        active();
+        const selected = input ?? snapshot.draft;
+        const files = answering ? [] : [...snapshot.shared.files];
+        if (!selected.text.trim() && !selected.attachments?.length && !files.length)
+            return;
+        if (selected.attachments?.length)
+            throw new Error('Use shared file attachments, not native image payloads');
+        const clientId = randomUUID();
+        const mentions = snapshot.shared.members.filter(member => hasMemberMention(selected.text, member)).map(member => member.id);
+        const payload = { conversationId: id, text: selected.text, mentions, clientId, ...(answering ? { replyTo: answering.replyTo } : snapshot.shared.replyTo ? { replyTo: snapshot.shared.replyTo } : {}), ...(files.length ? { attachments: files } : {}) };
+        const result = outbox.enqueue(clientId, payload);
+        // The sender's own copy is in the thread at once, marked pending: the host's message with the same clientId replaces it
+        // (merge), whether it comes back from send, the live socket or a history read. A refusal takes it out again.
+        const local = { id: `pending:${clientId}`, conversationId: id, author: source.me.id, at: latestAt(snapshot.shared.messages), text: selected.text, mentions, clientId, pending: true,
+            ...(payload.replyTo ? { replyTo: payload.replyTo } : {}), ...(files.length ? { attachments: files.map(file => ({ path: file.name, title: file.name })) } : {}) };
+        publish({ shared: answering ? snapshot.shared : { ...snapshot.shared, files: [], replyTo: undefined }, ...(!input ? { draft: { text: '', attachments: [], version: snapshot.draft.version + 1 } } : {}), send: { kind: 'submitting' } });
+        merge([local]);
+        sendOne(clientId, payload);
+        try {
+            const message = await result;
+            publish({ send: { kind: 'admitted' } });
+            return message;
+        }
+        catch (error) {
+            if (!snapshot.disposed && error instanceof ChannelRequestError && error.refused) {
+                const current = snapshot.draft, others = snapshot.shared.messages.filter(message => message.id !== local.id);
+                publish(answering ? { send: { kind: 'blocked', reason: error.message }, shared: { ...snapshot.shared, messages: others } }
+                    : { send: { kind: 'blocked', reason: error.message }, draft: { ...current, text: [input?.restore?.text ?? selected.text, current.text].filter(Boolean).join('\n'), version: current.version + 1 },
+                        shared: { ...snapshot.shared, messages: others, files: [...files, ...snapshot.shared.files], replyTo: snapshot.shared.replyTo ?? payload.replyTo } });
+            }
+            return undefined;
+        }
+    };
     const controller = {
         getSnapshot: () => snapshot,
         subscribe: (listener) => { listeners.add(listener); return () => { listeners.delete(listener); }; },
@@ -190,38 +225,13 @@ export function createSharedChat(source, options) {
             }).catch(error => { unsubscribe?.(); unsubscribe = undefined; publish({ connection: { kind: 'error', error } }); }).finally(() => { opening = undefined; });
             return opening;
         },
-        send: async (_whenBusy, input) => {
+        send: (_whenBusy, input) => post(input),
+        /** Answers an agent's question with one of its choices (or any text): a reply to the question, leaving the composer and its reply as they are. */
+        answer: (question, text) => {
             active();
-            const selected = input ?? snapshot.draft;
-            const files = [...snapshot.shared.files];
-            if (!selected.text.trim() && !selected.attachments?.length && !files.length)
-                return;
-            if (selected.attachments?.length)
-                throw new Error('Use shared file attachments, not native image payloads');
-            const clientId = randomUUID();
-            const mentions = snapshot.shared.members.filter(member => hasMemberMention(selected.text, member)).map(member => member.id);
-            const payload = { conversationId: id, text: selected.text, mentions, clientId, ...(snapshot.shared.replyTo ? { replyTo: snapshot.shared.replyTo } : {}), ...(files.length ? { attachments: files } : {}) };
-            const result = outbox.enqueue(clientId, payload);
-            // The sender's own copy is in the thread at once, marked pending: the host's message with the same clientId replaces it
-            // (merge), whether it comes back from send, the live socket or a history read. A refusal takes it out again.
-            const local = { id: `pending:${clientId}`, conversationId: id, author: source.me.id, at: latestAt(snapshot.shared.messages), text: selected.text, mentions, clientId, pending: true,
-                ...(payload.replyTo ? { replyTo: payload.replyTo } : {}), ...(files.length ? { attachments: files.map(file => ({ path: file.name, title: file.name })) } : {}) };
-            publish({ shared: { ...snapshot.shared, files: [], replyTo: undefined }, ...(!input ? { draft: { text: '', attachments: [], version: snapshot.draft.version + 1 } } : {}), send: { kind: 'submitting' } });
-            merge([local]);
-            sendOne(clientId, payload);
-            try {
-                const message = await result;
-                publish({ send: { kind: 'admitted' } });
-                return message;
-            }
-            catch (error) {
-                if (!snapshot.disposed && error instanceof ChannelRequestError && error.refused) {
-                    const current = snapshot.draft;
-                    publish({ send: { kind: 'blocked', reason: error.message }, draft: { ...current, text: [input?.restore?.text ?? selected.text, current.text].filter(Boolean).join('\n'), version: current.version + 1 },
-                        shared: { ...snapshot.shared, messages: snapshot.shared.messages.filter(message => message.id !== local.id), files: [...files, ...snapshot.shared.files], replyTo: snapshot.shared.replyTo ?? payload.replyTo } });
-                }
-                return undefined;
-            }
+            if (!question.question || question.question.answered || question.conversationId !== id)
+                return Promise.reject(new Error('This question is not open'));
+            return post({ text, attachments: [] }, { replyTo: question.id });
         },
         reconcile: async () => {
             active();
@@ -277,3 +287,4 @@ function hasMemberMention(text, member) {
 }
 export { createFakeChannelSource } from './fake.js';
 export { createChannelSocket } from './socket.js';
+export { createRoomSource } from './room.js';

package/dist/shared-chat/room.d.ts

@@ -0,0 +1,41 @@
+import type { ChannelSource } from './source.js';
+/**
+ * A ChannelSource over the host's room door (`POST _room/<op>`, boring-factory `services/channel/room.mjs`) and its space
+ * WebSocket. The room is a pi-durable session: its order is the entry id, its view is the pure fold `roomView`, and a reader
+ * resumes from an entry id. The old `createChannelSocket` is untouched; this source is opt-in.
+ */
+export interface RoomWords {
+    /** The card an agent's message turns into after `stallMs` with no frame (budget B6). */
+    readonly stalled: string;
+    readonly retry: string;
+    /** The label of a card's action when the room names it by id only (`try`, `later`, `validate`). */
+    readonly actions: Readonly<Record<string, string>>;
+    /** Titles of the room's own conversations. */
+    readonly titles: Readonly<Record<string, string>>;
+}
+export interface RoomSourceOptions {
+    /** The app's URL, for example `https://app.example/`. The door is `<url>/_room/<op>`, the socket `<url>/spaces/<space>/live`. */
+    readonly url: string | URL;
+    readonly fetch?: (request: Request) => Promise<Response>;
+    /** Host subprotocol authentication may be supplied here. */
+    readonly open?: (url: URL) => WebSocket;
+    readonly reconnectMs?: number;
+    /** A socket that has not opened after this long is given up and retried. Default 10000. */
+    readonly openMs?: number;
+    /** Call `POST _channel/join` before anything else (default). `false` for a host that enrols people another way. */
+    readonly join?: boolean;
+    readonly locale?: 'en' | 'fr';
+    /** Overrides the words (the stalled line, Retry, the titles of `main` and `admin`). */
+    readonly words?: Partial<RoomWords>;
+    /** No frame for this long while an agent writes: its message offers Retry (B6). Default 8000. */
+    readonly stallMs?: number;
+    readonly now?: () => number;
+}
+export interface RoomSource extends ChannelSource {
+    readonly space: string;
+    readonly engine: 'room';
+    /** The last entry id this source has read for the conversation (what a resume asks `after`). */
+    readonly cursor: (conversationId: string) => number | undefined;
+}
+export declare function createRoomSource(options: RoomSourceOptions): Promise<RoomSource>;
+//# sourceMappingURL=room.d.ts.map