@agentshouse/mdruntime 0.1.0-alpha.5 → 0.1.0-alpha.50

package/dist/conversation.js

@@ -0,0 +1,635 @@
+import { conversationChangeSet } from './change-set.js';
+import { declaredFile } from './file.js';
+const QUIET = {
+    growingText: null,
+    plan: null,
+    workingNote: null,
+    questions: [],
+    process: null,
+    commands: [],
+    options: []
+};
+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.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(value) {
+    if (typeof value !== 'object' || value === null) return null;
+    const record = value;
+    if (typeof record.conversation !== 'string' || !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 message = acceptedMessage(entry);
+        if (message === null) return null;
+        messages.push(message);
+    }
+    return {
+        conversation: record.conversation,
+        messages,
+        ...record.next === undefined ? {} : {
+            next: record.next
+        }
+    };
+}
+function historyPages(result) {
+    if (result.kind !== 'action') return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null) return null;
+    const { histories } = answer;
+    if (!Array.isArray(histories)) return null;
+    const pages = [];
+    for (const entry of histories){
+        const page = historyPage(entry);
+        if (page === null) return null;
+        pages.push(page);
+    }
+    return pages;
+}
+function turnOf(result) {
+    if (result.kind !== 'action') return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null) return null;
+    const record = answer;
+    return typeof record.turn === 'string' ? record.turn : null;
+}
+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 messages = new Map();
+    const reads = new Map();
+    const drafts = new Map();
+    const sending = new Map();
+    const behind = new Set();
+    const gaps = new Map();
+    const lives = new Map();
+    const views = new Map();
+    let replicated = new Set();
+    let handedReplicated;
+    function liveOf(conversation) {
+        return lives.get(conversation) ?? QUIET;
+    }
+    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);
+        const facts = liveOf(conversation);
+        return {
+            conversation,
+            messages: shown.map(({ identity, turn, text, message })=>({
+                    identity,
+                    turn,
+                    text,
+                    message: structuredClone(message)
+                })),
+            growingText: facts.growingText === null ? null : {
+                ...facts.growingText
+            },
+            workingNote: facts.workingNote === null ? null : {
+                ...facts.workingNote
+            },
+            plan: structuredClone(facts.plan?.plan ?? null),
+            questions: structuredClone(facts.questions),
+            process: facts.process === null ? null : {
+                ...facts.process
+            },
+            commands: structuredClone(facts.commands),
+            options: structuredClone(facts.options),
+            chatDraft: draft === undefined || draft.turn !== null || sending.get(conversation)?.draft === draft ? null : {
+                text: draft.text,
+                files: [
+                    ...draft.files
+                ]
+            }
+        };
+    }
+    function emit(conversation) {
+        if (deps.closed()) return;
+        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 live(conversation, change) {
+        lives.set(conversation, {
+            ...liveOf(conversation),
+            ...change
+        });
+        emit(conversation);
+    }
+    function sealTurns(conversation, turns) {
+        const held = lives.get(conversation);
+        if (held === undefined) return false;
+        const growingText = held.growingText !== null && turns.has(held.growingText.turn) ? null : held.growingText;
+        const plan = held.plan !== null && turns.has(held.plan.turn) ? null : held.plan;
+        if (growingText === held.growingText && plan === held.plan) return false;
+        lives.set(conversation, {
+            ...held,
+            growingText,
+            plan
+        });
+        return true;
+    }
+    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 documented() {
+        const declaration = deps.cards();
+        if (declaration === undefined) return [];
+        const { documents } = await deps.documents(declaration.locator);
+        return documents.filter((document)=>typeof document.type === 'string');
+    }
+    function carded(documents) {
+        const declaration = deps.cards();
+        if (declaration === undefined) return [];
+        const cards = [];
+        for (const card of documents){
+            if (card.type !== declaration.type) continue;
+            const identity = card.fields[declaration.identity];
+            if (typeof identity === 'string') cards.push({
+                conversation: identity,
+                card
+            });
+        }
+        return cards;
+    }
+    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) || lives.has(conversation)) {
+                    changed.push(conversation);
+                }
+                messages.delete(conversation);
+                reads.delete(conversation);
+                drafts.delete(conversation);
+                behind.delete(conversation);
+                lives.delete(conversation);
+            }
+            if (changed.length > 0) deps.publish(conversationChangeSet(removed, changed));
+        });
+    }
+    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,
+                messages: [
+                    message
+                ],
+                ...advances ? {
+                    read: message.position
+                } : {},
+                sealed
+            });
+            messages.set(conversation, merged(messages.get(conversation) ?? [], [
+                message
+            ]));
+            if (advances) reads.set(conversation, message.position);
+            if (sealed) drafts.delete(conversation);
+            sealTurns(conversation, new Set([
+                message.turn
+            ]));
+            deps.publish(conversationChangeSet([
+                {
+                    conversation,
+                    identity: message.identity
+                }
+            ], [
+                conversation
+            ]));
+        });
+    }
+    async function readHistories(conversations) {
+        const generations = new Map(conversations.map((one)=>[
+                one,
+                gaps.get(one) ?? 0
+            ]));
+        const starts = new Map(conversations.map((one)=>[
+                one,
+                reads.get(one)
+            ]));
+        const arriving = new Map();
+        const complete = new Set();
+        let asking = conversations.map((conversation)=>({
+                conversation,
+                after: starts.get(conversation) ?? undefined
+            }));
+        while(asking.length > 0){
+            const result = await deps.call('conversation.history', {
+                conversations: asking.map(({ conversation, after })=>({
+                        conversation,
+                        ...after === undefined ? {} : {
+                            after
+                        }
+                    }))
+            });
+            const pages = historyPages(result);
+            if (pages === null) return result;
+            const asked = new Set(asking.map(({ conversation })=>conversation));
+            const following = [];
+            for (const page of pages){
+                if (!asked.has(page.conversation)) continue;
+                arriving.set(page.conversation, [
+                    ...arriving.get(page.conversation) ?? [],
+                    ...page.messages
+                ]);
+                if (page.next === undefined) complete.add(page.conversation);
+                else following.push({
+                    conversation: page.conversation,
+                    after: page.next
+                });
+            }
+            asking = following;
+        }
+        for (const [conversation, held] of arriving){
+            if (!complete.has(conversation)) continue;
+            await keepHistory(conversation, held, starts.get(conversation), generations.get(conversation) ?? 0);
+        }
+        return null;
+    }
+    function keepHistory(conversation, arriving, from, generation) {
+        return deps.durably(async (local)=>{
+            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);
+            sealTurns(conversation, new Set(arriving.map((message)=>message.turn)));
+            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
+                ]));
+            }
+        });
+    }
+    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
+            ]));
+        });
+    }
+    function invoke(name, conversation, extra = {}) {
+        return deps.call(name, {
+            conversation,
+            ...extra
+        });
+    }
+    const surface = {
+        async list () {
+            const declaration = deps.cards();
+            if (declaration === undefined) return [];
+            const documents = await documented();
+            const entries = carded(documents).map(({ conversation, card })=>({
+                    conversation,
+                    card,
+                    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 entries;
+        },
+        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 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, {
+                answer
+            });
+        },
+        interrupt (conversation) {
+            return invoke('conversation.interrupt', conversation);
+        },
+        kill (conversation) {
+            return invoke('conversation.kill', conversation);
+        },
+        async cancel (conversation, turn) {
+            const result = await invoke('conversation.cancel', conversation, {
+                turn
+            });
+            if (result.kind !== 'action') return result;
+            await withDraft(conversation, (current)=>current === undefined || current.turn !== turn ? undefined : {
+                    ...current,
+                    turn: null
+                });
+            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,
+        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);
+            }
+            drafts.clear();
+            for (const record of stored)drafts.set(record.conversation, record);
+        },
+        async reconcile () {
+            const named = new Set(carded(await documented()).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);
+        },
+        async catchUp (progress) {
+            const reading = [
+                ...behind
+            ].filter((conversation)=>replicated.has(conversation)).sort();
+            if (reading.length > 0 && !deps.closed()) {
+                const failed = await readHistories(reading);
+                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);
+        },
+        watch (conversation, options, deliver) {
+            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: deliver,
+                ready: false
+            };
+            view.watchers.add(watcher);
+            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 (!view.watchers.delete(watcher)) return;
+                if (view.watchers.size === 0) views.delete(key);
+            };
+        },
+        changed (set) {
+            for (const conversation of set.conversations)emit(conversation);
+        },
+        receive (event) {
+            if (deps.closed()) return;
+            const { conversation } = event;
+            if (event.kind === 'gap') {
+                if (replicated.has(conversation)) gap(conversation);
+                if (lives.delete(conversation)) emit(conversation);
+                return;
+            }
+            if (event.kind === 'growing-text') {
+                live(conversation, {
+                    growingText: {
+                        turn: event.turn,
+                        text: event.text
+                    }
+                });
+                return;
+            }
+            if (event.kind === 'plan') {
+                live(conversation, {
+                    plan: {
+                        turn: event.turn,
+                        plan: structuredClone(event.plan)
+                    }
+                });
+                return;
+            }
+            if (event.kind === 'working-note') {
+                live(conversation, {
+                    workingNote: event.note === null ? null : {
+                        noteId: event.note.noteId,
+                        text: event.note.text
+                    }
+                });
+                return;
+            }
+            if (event.kind === 'questions') {
+                live(conversation, {
+                    questions: structuredClone(event.questions)
+                });
+                return;
+            }
+            if (event.kind === 'process') {
+                live(conversation, {
+                    process: {
+                        running: event.running
+                    }
+                });
+                return;
+            }
+            if (event.kind === 'commands') {
+                live(conversation, {
+                    commands: structuredClone(event.commands)
+                });
+                return;
+            }
+            if (event.kind === 'options') {
+                live(conversation, {
+                    options: structuredClone(event.options)
+                });
+                return;
+            }
+            const arriving = acceptedMessage(event.message);
+            if (arriving === null) return;
+            if (replicated.has(conversation)) {
+                void keep(conversation, arriving).catch(()=>{});
+                return;
+            }
+            if (sealTurns(conversation, new Set([
+                arriving.turn
+            ]))) emit(conversation);
+        },
+        messages () {
+            return [
+                ...messages
+            ].flatMap(([conversation, held])=>held.map(({ identity, text })=>({
+                        conversation,
+                        identity,
+                        text
+                    })));
+        },
+        message (conversation, identity) {
+            const held = messages.get(conversation)?.find((message)=>message.identity === identity);
+            return held === undefined ? null : {
+                conversation,
+                identity,
+                text: held.text
+            };
+        },
+        close () {
+            views.clear();
+            lives.clear();
+        }
+    };
+}
+
+//# sourceMappingURL=conversation.js.map