@agentshouse/mdruntime 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/conversation.js

@@ -1,10 +1,33 @@
+import { conversationChangeSet } from './change-set.js';
 import { declaredFile } from './file.js';
-const NO_TURNS = new Set();
-function carriedMessage(value) {
+function ordered(left, right) {
+    if (left.position !== right.position) return left.position < right.position ? -1 : 1;
+    if (left.identity !== right.identity) return left.identity < right.identity ? -1 : 1;
+    return 0;
+}
+function merged(held, arriving) {
+    const byIdentity = new Map(held.map((message)=>[
+            message.identity,
+            message
+        ]));
+    for (const message of arriving)byIdentity.set(message.identity, message);
+    return [
+        ...byIdentity.values()
+    ].sort(ordered);
+}
+function acceptedMessage(value) {
     if (typeof value !== 'object' || value === null) return null;
     const record = value;
-    if (typeof record.turn !== 'string') return null;
-    return structuredClone(value);
+    if (typeof record.identity !== 'string' || typeof record.turn !== 'string' || typeof record.position !== 'string' || typeof record.text !== 'string') {
+        return null;
+    }
+    return {
+        identity: record.identity,
+        turn: record.turn,
+        position: record.position,
+        text: record.text,
+        message: structuredClone(record.message)
+    };
 }
 function historyPage(result) {
     if (result.kind !== 'action') return null;
@@ -12,14 +35,18 @@ function historyPage(result) {
     if (typeof answer !== 'object' || answer === null) return null;
     const record = answer;
     if (!Array.isArray(record.messages)) return null;
+    if (record.next !== undefined && typeof record.next !== 'string') return null;
     const messages = [];
     for (const entry of record.messages){
-        const carried = carriedMessage(entry);
-        if (carried !== null) messages.push(carried);
+        const message = acceptedMessage(entry);
+        if (message === null) return null;
+        messages.push(message);
     }
     return {
         messages,
-        cursor: typeof record.cursor === 'string' ? record.cursor : null
+        ...record.next === undefined ? {} : {
+            next: record.next
+        }
     };
 }
 function turnOf(result) {
@@ -29,182 +56,224 @@ function turnOf(result) {
     const record = answer;
     return typeof record.turn === 'string' ? record.turn : null;
 }
-function newest(held, page, arrived) {
-    const arriving = new Set(page.messages.map((entry)=>entry.turn));
-    const overlap = held.messages.findIndex((entry)=>arriving.has(entry.turn));
-    const carried = overlap === -1 ? [] : held.messages.slice(0, overlap);
-    const placed = new Set([
-        ...carried,
-        ...page.messages
-    ].map((entry)=>entry.turn));
-    const live = held.messages.filter((entry)=>arrived.has(entry.turn) && !placed.has(entry.turn));
-    return {
-        ...held,
-        messages: [
-            ...carried,
-            ...page.messages,
-            ...live
-        ],
-        cursor: overlap === -1 ? page.cursor : held.cursor
-    };
-}
-function older(held, page) {
-    const present = new Set(held.messages.map((entry)=>entry.turn));
-    return {
-        ...held,
-        messages: [
-            ...page.messages.filter((entry)=>!present.has(entry.turn)),
-            ...held.messages
-        ],
-        cursor: page.cursor
-    };
-}
-function sealed(held, arriving) {
-    const at = held.messages.findIndex((entry)=>entry.turn === arriving.turn);
-    if (at === -1) return {
-        ...held,
-        messages: [
-            ...held.messages,
-            arriving
-        ]
-    };
-    const messages = [
-        ...held.messages
-    ];
-    messages[at] = arriving;
-    return {
-        ...held,
-        messages
-    };
+function limitOf(options) {
+    const { limit } = options;
+    if (limit === undefined) return undefined;
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new Error(`conversation limit must be a non-negative integer, got ${String(limit)}`);
+    }
+    return limit;
 }
 export function createConversationStore(deps) {
-    const held = new Map();
-    const composed = new Map();
+    const messages = new Map();
+    const reads = new Map();
+    const drafts = new Map();
+    const sending = new Map();
+    const behind = new Set();
+    const gaps = new Map();
     const growing = new Map();
-    const viewers = new Set();
-    const issued = new Map();
-    const live = new Map();
-    let handed;
-    function heldOf(conversation) {
-        return held.get(conversation) ?? {
-            messages: [],
-            cursor: null,
-            summary: null
-        };
-    }
-    function instructionOf(conversation) {
-        return composed.get(conversation) ?? {
-            text: '',
-            files: [],
-            turn: null
-        };
-    }
-    function viewOf(conversation) {
-        const carried = heldOf(conversation);
-        const unsent = composed.get(conversation);
+    const summaries = new Map();
+    const views = new Map();
+    let replicated = new Set();
+    let handedReplicated;
+    let handedViewed;
+    function viewOf(conversation, limit) {
+        const held = messages.get(conversation) ?? [];
+        const shown = limit === undefined ? held : held.slice(Math.max(0, held.length - limit));
+        const draft = drafts.get(conversation);
         return {
             conversation,
-            messages: structuredClone(carried.messages),
-            olderPages: carried.cursor !== null,
+            messages: shown.map(({ identity, turn, text, message })=>({
+                    identity,
+                    turn,
+                    text,
+                    message: structuredClone(message)
+                })),
             growingText: growing.get(conversation) ?? null,
-            summary: structuredClone(carried.summary),
-            instruction: unsent === undefined || unsent.turn !== null ? null : {
-                text: unsent.text,
+            summary: structuredClone(summaries.get(conversation) ?? null),
+            chatDraft: draft === undefined || draft.turn !== null || sending.get(conversation)?.draft === draft ? null : {
+                text: draft.text,
                 files: [
-                    ...unsent.files
+                    ...draft.files
                 ]
             }
         };
     }
     function emit(conversation) {
         if (deps.closed()) return;
-        for (const viewer of viewers){
-            if (viewer.conversation === conversation && viewer.ready) viewer.notify(viewOf(conversation));
+        for (const view of views.values()){
+            if (view.conversation !== conversation) continue;
+            const ready = [
+                ...view.watchers
+            ].filter((watcher)=>watcher.ready);
+            if (ready.length === 0) continue;
+            const value = viewOf(conversation, view.limit);
+            for (const watcher of ready)watcher.notify(value);
         }
     }
     function viewed() {
         return [
             ...new Set([
-                ...viewers
-            ].map((viewer)=>viewer.conversation))
+                ...views.values()
+            ].map((view)=>view.conversation))
         ].sort();
     }
-    function hand() {
-        const path = deps.path();
-        if (path === undefined) return;
+    function handViewed() {
+        const stream = deps.stream();
+        if (stream === undefined) return;
         const open = viewed();
         const named = JSON.stringify(open);
-        if (named === handed) return;
-        handed = named;
-        path.view(open);
+        if (named === handedViewed) return;
+        handedViewed = named;
+        stream.view(open);
     }
-    function keptRecord(conversation) {
-        const carried = heldOf(conversation);
-        return {
-            conversation,
-            messages: carried.messages,
-            cursor: carried.cursor,
-            summary: carried.summary
-        };
+    function handReplicated() {
+        const stream = deps.stream();
+        if (stream === undefined) return;
+        const held = [
+            ...replicated
+        ].sort();
+        const named = JSON.stringify(held);
+        if (named === handedReplicated) return;
+        handedReplicated = named;
+        stream.replicate(held);
     }
-    async function settle(local, conversation) {
-        const sent = instructionOf(conversation).turn;
-        if (sent === null) return;
-        if (!heldOf(conversation).messages.some((entry)=>entry.turn === sent)) return;
-        composed.delete(conversation);
-        await local.dropInstruction(conversation);
+    function carded(documents) {
+        const declaration = deps.cards();
+        if (declaration === undefined) return [];
+        const cards = [];
+        for (const card of documents){
+            if (card.room !== declaration.locator || card.type !== declaration.type) continue;
+            const identity = card.fields[declaration.identity];
+            if (typeof identity === 'string') cards.push({
+                conversation: identity,
+                card
+            });
+        }
+        return cards;
     }
-    async function keep(conversation, next) {
-        const kept = await deps.durably(async (local)=>{
-            const following = next(heldOf(conversation));
-            if (following === null) return false;
-            held.set(conversation, following);
-            await local.keepConversation(keptRecord(conversation));
-            await settle(local, conversation);
-            return true;
+    async function remove(leaving) {
+        await deps.durably(async (local)=>{
+            await local.dropConversations(leaving);
+            const removed = [];
+            const changed = [];
+            for (const conversation of leaving){
+                for (const message of messages.get(conversation) ?? []){
+                    removed.push({
+                        conversation,
+                        identity: message.identity
+                    });
+                }
+                if (messages.has(conversation) || drafts.has(conversation) || growing.has(conversation) || summaries.has(conversation)) {
+                    changed.push(conversation);
+                }
+                messages.delete(conversation);
+                reads.delete(conversation);
+                drafts.delete(conversation);
+                behind.delete(conversation);
+                growing.delete(conversation);
+                summaries.delete(conversation);
+            }
+            if (changed.length > 0) deps.publish(conversationChangeSet(removed, changed));
         });
-        if (kept) emit(conversation);
-        return kept;
     }
-    async function keepInstruction(conversation, next) {
-        await deps.durably(async (local)=>{
-            const stored = next(instructionOf(conversation));
-            composed.set(conversation, stored);
-            await local.keepInstruction({
+    function gap(conversation) {
+        gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
+        behind.add(conversation);
+    }
+    function keep(conversation, message) {
+        return deps.durably(async (local)=>{
+            if (!replicated.has(conversation)) return;
+            const read = reads.get(conversation);
+            const advances = read !== undefined && !behind.has(conversation) && (read === null || message.position > read);
+            const sealed = drafts.get(conversation)?.turn === message.turn;
+            await local.keepMessages({
                 conversation,
-                ...stored
+                messages: [
+                    message
+                ],
+                ...advances ? {
+                    read: message.position
+                } : {},
+                sealed
             });
-            await settle(local, conversation);
+            messages.set(conversation, merged(messages.get(conversation) ?? [], [
+                message
+            ]));
+            if (advances) reads.set(conversation, message.position);
+            if (sealed) drafts.delete(conversation);
+            if (growing.get(conversation)?.turn === message.turn) growing.delete(conversation);
+            deps.publish(conversationChangeSet([
+                {
+                    conversation,
+                    identity: message.identity
+                }
+            ], [
+                conversation
+            ]));
         });
-        emit(conversation);
     }
-    async function dropInstruction(conversation) {
+    async function readHistory(conversation) {
+        const generation = gaps.get(conversation) ?? 0;
+        const from = reads.get(conversation);
+        const arriving = [];
+        let after = from ?? undefined;
+        for(;;){
+            const result = await deps.call('conversation.history', {
+                conversation,
+                ...after === undefined ? {} : {
+                    after
+                }
+            });
+            const page = historyPage(result);
+            if (page === null) return result;
+            arriving.push(...page.messages);
+            if (page.next === undefined) break;
+            after = page.next;
+        }
         await deps.durably(async (local)=>{
-            composed.delete(conversation);
-            await local.dropInstruction(conversation);
+            if (!replicated.has(conversation)) return;
+            const newest = arriving.reduce((top, message)=>top === null || message.position > top ? message.position : top, from ?? null);
+            const turn = drafts.get(conversation)?.turn;
+            const sealed = arriving.some((message)=>message.turn === turn);
+            await local.keepMessages({
+                conversation,
+                messages: arriving,
+                read: newest,
+                sealed
+            });
+            messages.set(conversation, merged(messages.get(conversation) ?? [], arriving));
+            reads.set(conversation, newest);
+            if (sealed) drafts.delete(conversation);
+            const growingTurn = growing.get(conversation)?.turn;
+            if (arriving.some((message)=>message.turn === growingTurn)) growing.delete(conversation);
+            if ((gaps.get(conversation) ?? 0) === generation) behind.delete(conversation);
+            if (arriving.length > 0 || sealed) {
+                deps.publish(conversationChangeSet(arriving.map((message)=>({
+                        conversation,
+                        identity: message.identity
+                    })), [
+                    conversation
+                ]));
+            }
         });
-        emit(conversation);
-    }
-    function supersede(conversation) {
-        issued.set(conversation, (issued.get(conversation) ?? 0) + 1);
+        return null;
     }
-    async function fill(conversation, cursor) {
-        const generation = issued.get(conversation);
-        const result = await deps.call('conversation.history', {
-            conversation,
-            ...cursor === null ? {} : {
-                cursor
+    function withDraft(conversation, next) {
+        return deps.durably(async (local)=>{
+            const following = next(drafts.get(conversation));
+            if (following === undefined) return;
+            if (following === null) {
+                await local.dropChatDraft(conversation);
+                drafts.delete(conversation);
+            } else {
+                await local.keepChatDraft(following);
+                drafts.set(conversation, following);
             }
+            deps.publish(conversationChangeSet([], [
+                conversation
+            ]));
         });
-        const page = historyPage(result);
-        if (page === null) return result;
-        const landed = await keep(conversation, (carried)=>{
-            if (issued.get(conversation) !== generation) return null;
-            if (cursor !== null) return carried.cursor === cursor ? older(carried, page) : null;
-            return newest(carried, page, live.get(conversation) ?? NO_TURNS);
-        });
-        if (landed && cursor === null) live.delete(conversation);
-        return result;
     }
     function invoke(name, conversation, extra = {}) {
         return deps.call(name, {
@@ -216,62 +285,63 @@ export function createConversationStore(deps) {
         list () {
             const declaration = deps.cards();
             if (declaration === undefined) return Promise.resolve([]);
-            const documents = deps.documents().documents.filter((document)=>document.room === declaration.locator);
-            const entries = [];
-            for (const card of documents){
-                if (card.type !== declaration.type) continue;
-                const identity = card.fields[declaration.identity];
-                if (typeof identity !== 'string') continue;
-                const agent = documents.find((document)=>document.backlinks.some((backlink)=>backlink.path === card.path && backlink.field === declaration.agent));
-                entries.push({
-                    conversation: identity,
+            const documents = deps.documents().filter((document)=>document.room === declaration.locator);
+            const entries = carded(documents).map(({ conversation, card })=>({
+                    conversation,
                     card,
-                    agent: agent ?? null
-                });
-            }
+                    agent: documents.find((document)=>document.backlinks.some((backlink)=>backlink.path === card.path && backlink.field === declaration.agent)) ?? null
+                }));
             entries.sort((left, right)=>left.conversation < right.conversation ? -1 : 1);
             return Promise.resolve(entries);
         },
-        read (conversation) {
-            return deps.durably(()=>Promise.resolve(viewOf(conversation)));
-        },
-        older (conversation) {
-            const cursor = heldOf(conversation).cursor;
-            if (cursor === null) return Promise.resolve(null);
-            return fill(conversation, cursor);
-        },
-        compose (conversation, supplied) {
-            return keepInstruction(conversation, ()=>({
-                    text: supplied.text,
-                    files: [
-                        ...supplied.files
-                    ],
-                    turn: null
-                }));
-        },
-        discard (conversation) {
-            return dropInstruction(conversation);
+        async read (conversation, options = {}) {
+            const limit = limitOf(options);
+            return deps.durably(()=>Promise.resolve(viewOf(conversation, limit)));
         },
         create (input) {
             return deps.call('conversation.create', input);
         },
         async send (conversation) {
-            const unsent = instructionOf(conversation);
-            const files = await Promise.all(unsent.files.map(async (file)=>({
-                    ...await declaredFile(file),
-                    blob: file.blob
-                })));
-            const result = await invoke('conversation.send', conversation, {
-                text: unsent.text,
-                files
-            });
-            const turn = turnOf(result);
-            if (turn === null) return result;
-            await keepInstruction(conversation, (stored)=>({
-                    ...stored,
-                    turn
-                }));
-            return result;
+            const draft = drafts.get(conversation);
+            const pending = draft === undefined ? undefined : {
+                draft
+            };
+            if (pending !== undefined) {
+                sending.set(conversation, pending);
+                deps.publish(conversationChangeSet([], [
+                    conversation
+                ]));
+            }
+            try {
+                const files = await Promise.all((draft?.files ?? []).map(async (file)=>({
+                        ...await declaredFile(file),
+                        blob: file.blob
+                    })));
+                const result = await invoke('conversation.send', conversation, {
+                    text: draft?.text ?? '',
+                    files
+                });
+                const turn = turnOf(result);
+                if (turn === null || draft === undefined) return result;
+                await withDraft(conversation, (current)=>{
+                    if (current !== draft) return undefined;
+                    const sealed = (messages.get(conversation) ?? []).some((message)=>message.turn === turn);
+                    return sealed ? null : {
+                        ...draft,
+                        turn
+                    };
+                });
+                return result;
+            } finally{
+                if (pending !== undefined && sending.get(conversation) === pending) {
+                    sending.delete(conversation);
+                    if (drafts.get(conversation) === draft) {
+                        deps.publish(conversationChangeSet([], [
+                            conversation
+                        ]));
+                    }
+                }
+            }
         },
         answer (conversation, answer) {
             return invoke('conversation.answer', conversation, {
@@ -289,114 +359,146 @@ export function createConversationStore(deps) {
                 turn
             });
             if (result.kind !== 'action') return result;
-            if (instructionOf(conversation).turn === turn) {
-                await keepInstruction(conversation, (stored)=>({
-                        ...stored,
-                        turn: null
-                    }));
-            }
+            await withDraft(conversation, (current)=>current === undefined || current.turn !== turn ? undefined : {
+                    ...current,
+                    turn: null
+                });
             return result;
         },
-        async delete (conversation) {
-            const result = await invoke('conversation.delete', conversation);
-            if (result.kind !== 'action') return result;
-            growing.delete(conversation);
-            live.delete(conversation);
-            supersede(conversation);
-            await deps.durably(async (local)=>{
-                held.delete(conversation);
-                composed.delete(conversation);
-                await local.dropConversation(conversation);
-                await local.dropInstruction(conversation);
-            });
-            emit(conversation);
-            return result;
+        delete (conversation) {
+            return invoke('conversation.delete', conversation);
+        }
+    };
+    const chatDraft = {
+        write (conversation, draft) {
+            return withDraft(conversation, ()=>({
+                    conversation,
+                    text: draft.text,
+                    files: [
+                        ...draft.files
+                    ],
+                    turn: null
+                }));
+        },
+        discard (conversation) {
+            return withDraft(conversation, (current)=>current === undefined ? undefined : null);
         }
     };
     return {
         surface,
-        hydrate (conversations, instructions) {
-            held.clear();
-            for (const stored of conversations){
-                held.set(stored.conversation, {
-                    messages: stored.messages,
-                    cursor: stored.cursor,
-                    summary: stored.summary
-                });
+        chatDraft,
+        hydrate (held, stored) {
+            messages.clear();
+            reads.clear();
+            for (const entry of held){
+                messages.set(entry.conversation, [
+                    ...entry.messages
+                ].sort(ordered));
+                if (entry.read !== undefined) reads.set(entry.conversation, entry.read);
             }
-            composed.clear();
-            for (const stored of instructions){
-                composed.set(stored.conversation, {
-                    text: stored.text,
-                    files: stored.files,
-                    turn: stored.turn
-                });
+            drafts.clear();
+            for (const record of stored)drafts.set(record.conversation, record);
+        },
+        async reconcile () {
+            const named = new Set(carded(deps.documents()).map((entry)=>entry.conversation));
+            const leaving = [
+                ...new Set([
+                    ...replicated,
+                    ...messages.keys(),
+                    ...reads.keys(),
+                    ...drafts.keys()
+                ])
+            ].filter((conversation)=>!named.has(conversation));
+            for (const conversation of named){
+                if (!replicated.has(conversation)) behind.add(conversation);
             }
+            replicated = named;
+            handReplicated();
+            if (leaving.length > 0) await remove(leaving);
         },
-        observe (conversation, notify) {
-            const first = !viewed().includes(conversation);
-            const viewer = {
+        async catchUp (progress) {
+            for (const conversation of [
+                ...behind
+            ].sort()){
+                if (deps.closed()) return;
+                if (!replicated.has(conversation)) continue;
+                const failed = await readHistory(conversation);
+                if (failed?.kind === 'transport-uncertainty') progress.reachable = false;
+            }
+            if (behind.size > 0) progress.complete = false;
+        },
+        current () {
+            return behind.size === 0;
+        },
+        reconnected () {
+            for (const conversation of replicated)gap(conversation);
+        },
+        observe (conversation, options, notify) {
+            const limit = limitOf(options);
+            const key = JSON.stringify([
                 conversation,
+                limit ?? null
+            ]);
+            const view = views.get(key) ?? {
+                conversation,
+                limit,
+                watchers: new Set()
+            };
+            views.set(key, view);
+            const watcher = {
                 notify,
                 ready: false
             };
-            viewers.add(viewer);
-            if (first) {
-                live.set(conversation, new Set());
-                supersede(conversation);
-            }
-            hand();
-            void deps.durably(()=>Promise.resolve()).then(async ()=>{
-                if (deps.closed() || !viewers.has(viewer)) return;
-                viewer.ready = true;
-                viewer.notify(viewOf(conversation));
-                if (first) await fill(conversation, null);
+            view.watchers.add(watcher);
+            handViewed();
+            void deps.durably(()=>Promise.resolve()).then(()=>{
+                if (deps.closed() || !view.watchers.has(watcher)) return;
+                watcher.ready = true;
+                watcher.notify(viewOf(conversation, limit));
             }).catch(()=>{});
             return ()=>{
-                if (!viewers.delete(viewer)) return;
+                if (!view.watchers.delete(watcher)) return;
+                if (view.watchers.size === 0) views.delete(key);
                 if (!viewed().includes(conversation)) {
                     growing.delete(conversation);
-                    live.delete(conversation);
+                    summaries.delete(conversation);
                 }
-                hand();
+                handViewed();
             };
         },
+        changed (set) {
+            for (const conversation of set.conversations)emit(conversation);
+        },
         receive (event) {
-            if (deps.closed() || !viewed().includes(event.conversation)) return;
+            if (deps.closed()) return;
+            const { conversation } = event;
+            if (event.kind === 'gap') {
+                if (replicated.has(conversation)) gap(conversation);
+                return;
+            }
             if (event.kind === 'growing-text') {
-                growing.set(event.conversation, {
+                if (!viewed().includes(conversation)) return;
+                growing.set(conversation, {
                     turn: event.turn,
                     text: event.text
                 });
-                emit(event.conversation);
+                emit(conversation);
                 return;
             }
             if (event.kind === 'session-summary') {
-                const summary = structuredClone(event.summary);
-                void keep(event.conversation, (carried)=>({
-                        ...carried,
-                        summary
-                    })).catch(()=>{});
+                if (!viewed().includes(conversation)) return;
+                summaries.set(conversation, structuredClone(event.summary));
+                emit(conversation);
                 return;
             }
-            const arriving = carriedMessage(event.message);
-            if (arriving === null) return;
-            live.get(event.conversation)?.add(arriving.turn);
-            if (growing.get(event.conversation)?.turn === arriving.turn) {
-                growing.delete(event.conversation);
-            }
-            void deps.durably(async (local)=>{
-                held.set(event.conversation, sealed(heldOf(event.conversation), arriving));
-                await local.keepConversation(keptRecord(event.conversation));
-                await settle(local, event.conversation);
-            }).then(()=>{
-                emit(event.conversation);
-            }).catch(()=>{});
+            const arriving = acceptedMessage(event.message);
+            if (arriving === null || !replicated.has(conversation)) return;
+            void keep(conversation, arriving).catch(()=>{});
         },
         close () {
-            viewers.clear();
+            views.clear();
             growing.clear();
-            live.clear();
+            summaries.clear();
         }
     };
 }