@hachej/boring-ui-kit 0.4.3 → 0.4.5

package/dist/native-chat.js

@@ -1,3 +1,4 @@
+import { awaitWithContext, withCancel } from '@earendil-works/chord/context';
 import { randomUUID } from '@hachej/boring-files/platform';
 function draft(text, attachments, version) {
     if (typeof text !== 'string' || attachments.some(item => typeof item.id !== 'string' || !item.id || typeof item.name !== 'string'
@@ -23,6 +24,8 @@ export function createNativeChatController(options) {
     const listeners = new Set();
     let watch, opening, disposing;
     const publish = (change) => {
+        if (snapshot.disposed)
+            return;
         snapshot = Object.freeze({ ...snapshot, ...change, ...(change.send ? { send: Object.freeze(change.send) } : {}),
             ...(change.connection ? { connection: Object.freeze(change.connection) } : {}),
             ...(change.history ? { history: Object.freeze(change.history) } : {}), ...(change.outbox ? { outbox: Object.freeze(change.outbox) } : {}) });
@@ -57,7 +60,27 @@ export function createNativeChatController(options) {
         historyScan = undefined;
         return emptyHistory();
     };
+    const restoring = new Map();
+    const hasText = (messages) => messages?.some(message => message.role === 'assistant' && Array.isArray(message.content) && message.content.some(part => part?.type === 'text' && typeof part.text === 'string' && part.text.length > 0)) ?? false;
+    const observeText = (view) => {
+        const live = view.docs['pi.live'], run = live?.['run'];
+        if (!run || typeof run !== 'object' || Array.isArray(run))
+            return;
+        const inputs = run['inputs'], taskId = run['taskId'], generation = live?.['generation'];
+        const message = generation && typeof generation === 'object' && !Array.isArray(generation) ? generation['message'] : undefined;
+        const streamed = message && typeof message === 'object' && !Array.isArray(message) && hasText([{ role: 'assistant', content: message['content'] }]);
+        if (!Array.isArray(inputs))
+            return;
+        for (const item of restoring.values())
+            if (inputs.includes(item.submissionId)) {
+                if (typeof taskId === 'number')
+                    item.runTaskId = taskId;
+                if (streamed || view.entries.some(entry => entry.byTaskId === taskId && hasText(entry.model)))
+                    item.textObserved = true;
+            }
+    };
     const acceptView = (view) => {
+        observeText(view);
         const previous = snapshot.view?.entries;
         const appendOnly = !previous || previous.every((entry, index) => view.entries[index]?.id === entry.id);
         publish({ view, ...(!appendOnly ? { history: invalidateHistory() } : {}) });
@@ -68,9 +91,10 @@ export function createNativeChatController(options) {
     const editable = () => { active(); return snapshot.draft; };
     // The composer is emptied when a message is sent, so a confirmation never has to clear it (text typed meanwhile is a new draft).
     const markAdmitted = (attempt, submissionId, record) => {
-        if (!stillPending(attempt))
-            return;
+        if (snapshot.disposed || !stillPending(attempt))
+            return false;
         publish({ send: { kind: 'admitted', attempt, submissionId, ...(record ? { record } : {}) } });
+        return true;
     };
     /** Messages taken from the composer that wait for the current send (`outbox` in the snapshot). */
     const waiting = [];
@@ -87,11 +111,16 @@ export function createNativeChatController(options) {
             item.resolve(undefined);
         if (snapshot.disposed)
             return;
-        const current = snapshot.draft, back = [...drafts, ...left.map(item => item.draft)].map(item => restoreOf.get(item) ?? item);
+        putBack([...drafts, ...left.map(item => item.draft)], { ...change, ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}) });
+    };
+    function putBack(selected, change = {}) {
+        if (snapshot.disposed)
+            return;
+        const current = snapshot.draft, back = selected.map(item => restoreOf.get(item) ?? item);
         const text = [...back.map(item => item.text), current.text].filter(value => value.trim()).join('\n');
         const attachments = [...back.flatMap(item => item.attachments), ...current.attachments].filter((item, index, all) => all.findIndex(other => other.id === item.id) === index);
-        publish({ ...change, ...(left.length || snapshot.outbox.length ? { outbox: Object.freeze([]) } : {}), ...(back.length ? { draft: draft(text, attachments, current.version + 1) } : {}) });
-    };
+        publish({ ...change, ...(back.length ? { draft: draft(text, attachments, current.version + 1) } : {}) });
+    }
     function definitelyNotAdmitted(error) {
         try {
             return options.definitelyNotAdmitted?.(error) === true;
@@ -100,6 +129,53 @@ export function createNativeChatController(options) {
             return false;
         }
     }
+    function monitor(attempt, submission) {
+        if (!options.restoreOnError || snapshot.disposed || restoring.has(attempt.requestId))
+            return;
+        const waiter = withCancel(context);
+        const item = { submissionId: submission.id, cancel: waiter.cancel, textObserved: false };
+        restoring.set(attempt.requestId, item);
+        if (snapshot.view)
+            observeText(snapshot.view);
+        void (async () => {
+            try {
+                const record = await awaitWithContext(submission.wait(waiter.context), waiter.context);
+                if (snapshot.disposed || record.id !== item.submissionId || record.conversationId !== conversation.id || record.requestId !== attempt.requestId || record.type !== 'input'
+                    || record.status !== 'unanswered' || !['model_error', 'no_model', 'faulted'].includes(record.reason) || record.entry === undefined || item.textObserved)
+                    return;
+                // The native transcript, not watch timing or connection loss, decides whether the failed input received any text.
+                const minEntryId = record.entry, detail = record.detail;
+                const newest = await awaitWithContext(conversation.entries({}, 1, undefined, waiter.context), waiter.context);
+                const maxEntryId = newest.items[0]?.id;
+                if (maxEntryId === undefined || maxEntryId < minEntryId)
+                    return;
+                let cursor, ended = false;
+                do {
+                    const page = await awaitWithContext(conversation.entries({ minEntryId, maxEntryId, order: 'ascending' }, 40, cursor, waiter.context), waiter.context);
+                    if (snapshot.disposed || item.textObserved)
+                        return;
+                    for (const entry of page.items) {
+                        if (hasText(entry.model))
+                            return;
+                        // One run may consume several inputs and retain interrupted attempts. Neither is the final error boundary.
+                        if (entry.model?.some(message => message.role === 'assistant' && message.stopReason === 'error'
+                            && (item.runTaskId !== undefined ? entry.byTaskId === item.runTaskId : typeof detail === 'string' && message.errorMessage === detail))) {
+                            ended = true;
+                            break;
+                        }
+                    }
+                    cursor = page.next;
+                } while (!ended && cursor !== undefined);
+                if (!snapshot.disposed && !item.textObserved)
+                    putBack([attempt.draft]);
+            }
+            catch { /* Missing settlement/history is unknown, never proof of an empty failed answer. */ }
+            finally {
+                restoring.delete(attempt.requestId);
+                waiter.cancel();
+            }
+        })();
+    }
     async function submitAttempt(attempt) {
         publish({ send: { kind: 'submitting', attempt }, ...(!stopping && snapshot.stop !== 'idle' ? { stop: 'idle' } : {}) });
         if (snapshot.disposed)
@@ -109,7 +185,8 @@ export function createNativeChatController(options) {
                 ? [{ type: 'text', text: attempt.draft.text }, ...attempt.draft.attachments.map(item => ({ ...item.content }))]
                 : attempt.draft.text;
             const submission = await conversation.submit({ type: 'input', requestId: attempt.requestId, content, whenBusy: attempt.whenBusy }, context);
-            markAdmitted(attempt, submission.id);
+            if (markAdmitted(attempt, submission.id))
+                monitor(attempt, submission);
             return submission;
         }
         catch (error) {
@@ -151,6 +228,15 @@ export function createNativeChatController(options) {
     const controller = {
         conversation,
         getSnapshot: () => snapshot,
+        /** Reads the exact native submission with this controller's Context; observing never aborts or owns its execution. */
+        submissionStatus: async (submission) => {
+            active();
+            const record = await submission.status(context);
+            active();
+            if (record.id !== submission.id || record.conversationId !== conversation.id)
+                throw new Error('Submission belongs to a different conversation');
+            return record;
+        },
         subscribe: (listener) => { if (snapshot.disposed)
             return () => { }; listeners.add(listener); return () => { listeners.delete(listener); }; },
         setText: (text) => { const current = editable(); publish({ draft: draft(text, current.attachments, current.version + 1) }); },
@@ -316,7 +402,22 @@ export function createNativeChatController(options) {
             if (record) {
                 if (record.conversationId !== conversation.id || record.requestId !== attempt.requestId || record.type !== 'input')
                     throw new Error('Native submission lookup returned a different binding');
-                markAdmitted(attempt, record.id, record);
+                const admitted = markAdmitted(attempt, record.id, record);
+                if (admitted && options.restoreOnError) {
+                    // Reconciliation observes the original request only; no duplicate submission is made to obtain a handle.
+                    monitor(attempt, { id: record.id, wait: async (waiter) => {
+                            for (;;) {
+                                if (waiter.abortSignal?.aborted)
+                                    throw waiter.abortSignal.reason;
+                                const current = await awaitWithContext(conversation.commit(tx => tx.submissionByRequest(conversation.id, attempt.requestId), waiter), waiter);
+                                if (!current || current.id !== record.id)
+                                    throw new Error('Submission binding is unavailable');
+                                if (current.status === 'done' || current.status === 'unanswered')
+                                    return current;
+                                await awaitWithContext(new Promise(resolve => setTimeout(resolve, 250)), waiter);
+                            }
+                        } });
+                }
             }
             return record;
         },
@@ -367,6 +468,9 @@ export function createNativeChatController(options) {
                 return disposing;
             disposing = Promise.resolve().then(async () => { await opening; const owned = watch; watch = undefined; return owned?.stop(); });
             unlink?.();
+            for (const item of restoring.values())
+                item.cancel();
+            restoring.clear();
             publish({ disposed: true, connection: { kind: 'closed' }, history: invalidateHistory() });
             listeners.clear();
             return disposing;

package/dist/remote-chat.js

@@ -1,4 +1,6 @@
+import { awaitWithContext, BACKGROUND_CONTEXT } from '@earendil-works/chord/context';
 import { applyImmutable } from '@earendil-works/chord/delta';
+import { createChatOutbox } from './chat-outbox.js';
 /** A watch request the host answered with an error status. */
 class WatchRefused extends Error {
     status;
@@ -40,17 +42,19 @@ export async function createRemoteChat(options) {
     // The transport in use: `websocket` until its first socket fails to open, then `http` for good.
     let mode = options.transport ?? 'http', current, seq = 0;
     /** Calls sent over a socket and not answered yet, by call ID: sent again unchanged on the next socket. */
-    const outbox = new Map();
+    const outbox = createChatOutbox();
     function exchange(op, init, extra) {
         const http = () => new Request(url(op, extra), init);
         if (mode !== 'websocket')
             return send(http());
         const id = `c${++seq}`;
         const text = JSON.stringify({ kind: 'call', id, op, params: extra, ...(typeof init.body === 'string' ? { body: JSON.parse(init.body) } : {}) });
-        return new Promise((resolve, reject) => { outbox.set(id, { text, http, resolve, reject }); try {
+        const pending = outbox.enqueue(id, { text, http });
+        try {
             current?.send(text);
         }
-        catch { /* sent again on the next socket */ } });
+        catch { /* sent again on the next socket */ }
+        return pending;
     }
     /** Leave the socket for HTTP: calls still waiting for a socket go over HTTP, unchanged (same request ID, so the host deduplicates). */
     function fallBack() {
@@ -58,7 +62,7 @@ export async function createRemoteChat(options) {
         const pending = [...outbox.values()];
         outbox.clear();
         for (const call of pending)
-            send(call.http()).then(call.resolve, call.reject);
+            send(call.input.http()).then(call.resolve, call.reject);
     }
     async function call(op, init = {}, extra = {}) {
         const response = await exchange(op, init, extra);
@@ -135,11 +139,7 @@ export async function createRemoteChat(options) {
                     return;
                 }
                 if (frame.kind === 'reply') {
-                    const pending = outbox.get(frame.id);
-                    if (pending) {
-                        outbox.delete(frame.id);
-                        pending.resolve(new Response(JSON.stringify(frame.body), { status: frame.status, headers: { 'content-type': 'application/json' } }));
-                    }
+                    outbox.resolve(frame.id, new Response(JSON.stringify(frame.body), { status: frame.status, headers: { 'content-type': 'application/json' } }));
                     return;
                 }
                 if (frame.kind === 'event') {
@@ -158,7 +158,7 @@ export async function createRemoteChat(options) {
                     current = socket;
                     // Unanswered calls go again, unchanged: a submit keeps its request ID, so the host runs it once.
                     for (const pending of outbox.values())
-                        socket.send(pending.text);
+                        socket.send(pending.input.text);
                     ready({ first: frame.view, next, cancel });
                     return;
                 }
@@ -442,11 +442,13 @@ export async function createRemoteChat(options) {
                 throw new Error('Submission is unknown to the remote host'); return record; };
             return {
                 id: submissionId, status,
-                wait: async () => { for (;;) {
-                    const record = await status();
+                wait: async (context) => { for (;;) {
+                    if (context.abortSignal?.aborted)
+                        throw context.abortSignal.reason;
+                    const record = await awaitWithContext(status(), context);
                     if (record.status === 'done' || record.status === 'unanswered')
                         return record;
-                    await new Promise(resolve => setTimeout(resolve, pollMs));
+                    await awaitWithContext(new Promise(resolve => setTimeout(resolve, pollMs)), context);
                 } },
                 abort: () => withdraw(submissionId, requestId),
             };
@@ -460,7 +462,7 @@ export async function createRemoteChat(options) {
             ...(query.order === undefined ? {} : { order: query.order }),
             ...(cursor === undefined ? {} : { cursor: JSON.stringify(cursor) }) })).page,
     };
-    const context = Object.freeze({});
+    const context = BACKGROUND_CONTEXT;
     const close = async () => { const first = unclaimed; unclaimed = undefined; await first?.stop(); };
     return { conversation, context, close, link, withdraw: id => withdraw(id), definitelyNotAdmitted: error => error instanceof SubmissionRefused,
         answer: (callId, answer) => post('answer', { callId, answer }), configure: change => post('configure', change) };

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

@@ -0,0 +1,10 @@
+/** A channel failure's message and retryability come from the host, or from an unconfirmed transport failure. */
+export declare class ChannelRequestError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly refused: boolean;
+    constructor(code: string, message: string, retryable: boolean, options?: {
+        readonly refused?: boolean;
+    });
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/shared-chat/error.js

@@ -0,0 +1,13 @@
+/** A channel failure's message and retryability come from the host, or from an unconfirmed transport failure. */
+export class ChannelRequestError extends Error {
+    code;
+    retryable;
+    refused;
+    constructor(code, message, retryable, options) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.name = 'ChannelRequestError';
+        this.refused = options?.refused ?? false;
+    }
+}

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

@@ -0,0 +1,39 @@
+import type { ChannelEvent, ChannelMessage, ChannelSource, Conversation, Member, SharedChatState } from './source.js';
+export interface FakeChannelSeed {
+    readonly me: Member;
+    readonly members: Member[];
+    readonly conversations: Conversation[];
+    readonly messages: ChannelMessage[];
+}
+/** Fictional in-memory host. The controls exercise exactly the source events a real host delivers. */
+export declare function createFakeChannelSource(seed: FakeChannelSeed): {
+    me: Member;
+    conversations: () => Promise<Conversation[]>;
+    members: (id: string) => Promise<Member[]>;
+    history: (id: string, opts: {
+        before?: string;
+        limit: number;
+    }) => Promise<{
+        before?: string;
+        messages: ChannelMessage[];
+    }>;
+    send: (input: Parameters<ChannelSource["send"]>[0]) => Promise<ChannelMessage>;
+    action: (input: Parameters<ChannelSource["action"]>[0]) => Promise<void>;
+    subscribe: (id: string, event: (event: ChannelEvent) => void, status?: (status: SharedChatState["status"]) => void) => () => void;
+    emit: (event: ChannelEvent) => void;
+    sends: {
+        conversationId: string;
+        text: string;
+        mentions: string[];
+        replyTo?: string;
+        clientId: string;
+        attachments?: File[];
+    }[];
+    actions: {
+        conversationId: string;
+        requestId: string;
+        actionId: string;
+    }[];
+    setStatus: (status: SharedChatState["status"]) => void;
+};
+//# sourceMappingURL=fake.d.ts.map

package/dist/shared-chat/fake.js

@@ -0,0 +1,90 @@
+import { ChannelRequestError } from './error.js';
+/** Fictional in-memory host. The controls exercise exactly the source events a real host delivers. */
+export function createFakeChannelSource(seed) {
+    const data = structuredClone(seed);
+    const listeners = new Set();
+    const sends = [], actions = [];
+    let online = true;
+    function emit(event) {
+        if (event.type === 'message') {
+            const index = data.messages.findIndex(message => message.id === event.message.id);
+            if (index < 0)
+                data.messages.push(structuredClone(event.message));
+            else
+                data.messages[index] = structuredClone(event.message);
+        }
+        else if (event.type === 'delta') {
+            const message = data.messages.find(message => message.id === event.messageId && message.conversationId === event.conversationId);
+            if (message) {
+                message.text = (message.text ?? '') + event.text;
+                message.streaming = true;
+            }
+        }
+        else if (event.type === 'step') {
+            const message = data.messages.find(message => message.id === event.messageId && message.conversationId === event.conversationId);
+            if (message && Number.isSafeInteger(event.index) && event.index >= 0) {
+                const steps = [...(message.steps ?? [])];
+                steps[event.index] = { ...event.step };
+                message.steps = steps;
+            }
+        }
+        else if (event.type === 'presence')
+            for (const update of event.members) {
+                const member = data.members.find(member => member.id === update.id);
+                if (member)
+                    member.presence = update.presence;
+            }
+        else if (event.type === 'members') {
+            for (const member of event.members) {
+                const index = data.members.findIndex(existing => existing.id === member.id);
+                if (index < 0)
+                    data.members.push(structuredClone(member));
+                else
+                    data.members[index] = structuredClone(member);
+            }
+            const conversation = data.conversations.find(conversation => conversation.id === event.conversationId);
+            if (conversation)
+                conversation.members = event.members.map(member => member.id);
+        }
+        if (online)
+            for (const listener of [...listeners]) {
+                const id = event.type === 'message' ? event.message.conversationId : event.type === 'presence' ? undefined : event.conversationId;
+                if (id === undefined || id === listener.id)
+                    listener.event(structuredClone(event));
+            }
+    }
+    return {
+        me: data.me,
+        conversations: async () => structuredClone(data.conversations),
+        members: async (id) => structuredClone(data.members.filter(member => data.conversations.find(conversation => conversation.id === id)?.members.includes(member.id))),
+        history: async (id, opts) => {
+            const all = data.messages.filter(message => message.conversationId === id);
+            const end = opts.before ? all.findIndex(message => message.id === opts.before) : all.length;
+            if (end < 0)
+                throw new Error('Unknown history cursor');
+            const start = Math.max(0, end - opts.limit);
+            return { messages: structuredClone(all.slice(start, end)), ...(start > 0 && all[start] ? { before: all[start].id } : {}) };
+        },
+        send: async (input) => {
+            sends.push({ ...input, mentions: [...input.mentions], ...(input.attachments ? { attachments: [...input.attachments] } : {}) });
+            if (!online)
+                throw new ChannelRequestError('offline', 'Offline', true);
+            const duplicate = data.messages.find(message => message.clientId === input.clientId && message.conversationId === input.conversationId);
+            if (duplicate)
+                return structuredClone(duplicate);
+            const message = { id: `sent-${input.clientId}`, conversationId: input.conversationId, author: data.me.id, at: new Date().toISOString(), text: input.text, mentions: [...input.mentions], clientId: input.clientId, ...(input.replyTo ? { replyTo: input.replyTo } : {}) };
+            emit({ type: 'message', message });
+            return structuredClone(message);
+        },
+        action: async (input) => { actions.push(structuredClone(input)); },
+        subscribe: (id, event, status) => {
+            const listener = { id, event, status };
+            listeners.add(listener);
+            status?.(online ? 'live' : 'offline');
+            return () => { listeners.delete(listener); };
+        },
+        emit, sends, actions,
+        setStatus: (status) => { online = status === 'live'; for (const listener of [...listeners])
+            listener.status?.(status); },
+    };
+}

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

@@ -0,0 +1,51 @@
+import type { ChatAttempt, ChatDraft, ChatSendInput, NativeChatSnapshot } from '../native-chat.js';
+export { ChannelRequestError } from './error.js';
+import type { Card, ChannelMessage, ChannelSource, Member, SharedChatState } from './source.js';
+export type * from './source.js';
+export { channelAvatarStates } from './source.js';
+export type SharedChatSnapshot = Omit<NativeChatSnapshot, 'conversationId' | 'send' | 'shared'> & {
+    readonly conversationId: string;
+    readonly shared: SharedChatState;
+    readonly send: {
+        readonly kind: 'idle' | 'submitting' | 'admitted';
+    } | {
+        readonly kind: 'unknown';
+        readonly reason: string;
+        readonly retryable: boolean;
+    } | {
+        readonly kind: 'blocked';
+        readonly reason: string;
+    };
+};
+export type { ChatController, ChatSnapshot } from '../native-chat.js';
+/** Host-owned multi-party log, not a Pi conversation or an agent runtime. One adapter per selected conversation. */
+export declare function createSharedChat(source: ChannelSource, options: {
+    readonly conversationId: string;
+    readonly limit?: number;
+}): {
+    getSnapshot: () => SharedChatSnapshot;
+    subscribe: (listener: () => void) => () => void;
+    setText: (text: string) => void;
+    setAttachments: (attachments: ChatDraft["attachments"]) => void;
+    setFiles: (files: readonly File[]) => void;
+    setReplyTo: (messageId: string | undefined) => void;
+    clearHistory: () => void;
+    loadEarlier: () => Promise<void>;
+    connect: () => Promise<void>;
+    send: (_whenBusy?: ChatAttempt["whenBusy"], input?: ChatSendInput) => Promise<ChannelMessage | undefined>;
+    reconcile: () => Promise<void>;
+    retrySameRequest: () => Promise<void>;
+    stop: () => Promise<never>;
+    dispose: () => Promise<undefined>;
+    action: (card: Card) => Promise<void>;
+    remove: ((message: ChannelMessage) => Promise<void>) | undefined;
+    canRemove: (message: ChannelMessage) => boolean;
+};
+export type SharedChatController = ReturnType<typeof createSharedChat>;
+/** The composer uses the existing quoted @ token grammar. Tokens carry stable member ids; picker labels show names. */
+export declare function memberMention(member: Member): string;
+export { createFakeChannelSource } from './fake.js';
+export type { FakeChannelSeed } from './fake.js';
+export { createChannelSocket } from './socket.js';
+export type { ChannelSocketOptions, ChannelSocketSource } from './socket.js';
+//# sourceMappingURL=index.d.ts.map