@agentshouse/mdruntime 0.1.0-ccbb89b0ca151 → 0.1.0-ccc0e3407f107

package/dist/conversation.js

@@ -1,9 +1,11 @@
+import { cursorOf, decodedCursor } from '@agentshouse/mdmodel';
 import { conversationChangeSet } from './change-set.js';
 import { runtimeError } from './failure.js';
 import { refusedForSpace } from './durability.js';
 import { changeBatchIdentity, chatDraftRevision } from './identity.js';
 import { OFFLINE } from './outcome.js';
-import { capped, cursorOf, decodedCursor, FROM_START, messageOrder, precedes } from './windows.js';
+import { untilAnswered } from './recovery.js';
+import { capped, FROM_START, messageOrder, precedes } from './windows.js';
 const QUIET = {
     turn: null,
     questions: [],
@@ -11,6 +13,7 @@ const QUIET = {
     commands: [],
     options: [],
     starting: null,
+    subagents: [],
     link: null,
     deliveryUnknown: [],
 };
@@ -20,6 +23,7 @@ const FACTS = [
     'commands',
     'options',
     'starting',
+    'subagents',
     'link',
     'deliveryUnknown',
 ];
@@ -30,9 +34,11 @@ export function unheldView(conversation) {
         turn: null,
         questions: [],
         process: null,
+        processEnded: null,
         commands: [],
         options: [],
         starting: null,
+        subagents: [],
         link: null,
         deliveryUnknown: [],
         chatDraft: null,
@@ -47,10 +53,8 @@ export function newChat(agent) {
 function creationOf(input) {
     if (typeof input !== 'object' || input === null)
         return null;
-    const { agent_id: agent, operation_id: operation, replaces, } = input;
-    return typeof agent === 'string' && typeof operation === 'string' && replaces === undefined
-        ? { agent, operation }
-        : null;
+    const { agent_id: agent, operation_id: operation } = input;
+    return typeof agent === 'string' && typeof operation === 'string' ? { agent, operation } : null;
 }
 function startedTurn(turn, operation) {
     if (operation.op === 'begin')
@@ -209,7 +213,14 @@ function askedOf(options) {
     }
     return { limit: capped(limit), after, before: beforeOf(after), total: total === true };
 }
-const EXPIRED = { kind: 'rejected', code: 'expired', fields: {}, retryable: false };
+function phraseOf(text) {
+    if (text === undefined)
+        return null;
+    if (typeof text !== 'string' || text === '') {
+        throw runtimeError('invalid-text', 'a conversation is found by a phrase');
+    }
+    return text;
+}
 const DURABLE_WRITE = {
     kind: 'rejected',
     code: 'durable-write',
@@ -255,13 +266,19 @@ export function createConversationStore(deps) {
     const unsent = new Map();
     const views = new Map();
     const listing = new Map();
+    let relisting = null;
+    let listCursor = null;
     const creations = new Set();
     const listWatchers = new Set();
+    const unlisted = new Set();
     let listKnown = false;
+    let listHeld = false;
+    let listKept = false;
     const agentWatchers = new Set();
-    let agentNames = new Map();
-    let retiredAgents = new Set();
-    let agentsRead = null;
+    const unnamed = new Set();
+    let agentsShown = null;
+    let listedAgents = null;
+    let agentsReading = false;
     let replicated = new Set();
     let handedReplicated;
     function liveOf(conversation) {
@@ -282,9 +299,11 @@ export function createConversationStore(deps) {
             turn: structuredClone(facts.turn),
             questions: structuredClone(facts.questions),
             process: facts.process === null ? null : { ...facts.process },
+            processEnded: listing.get(conversation)?.processEnded ?? null,
             commands: structuredClone(facts.commands),
             options: structuredClone(facts.options),
             starting: facts.starting,
+            subagents: structuredClone(facts.subagents),
             link: facts.link === null ? null : { ...facts.link },
             deliveryUnknown: [...facts.deliveryUnknown],
             chatDraft: draft === undefined || unwritten(draft)
@@ -340,7 +359,7 @@ export function createConversationStore(deps) {
     function entries() {
         return [...listing.values()].map((entry) => ({
             conversation: entry.conversation,
-            agent: { identity: entry.agent, name: agentNames.get(entry.agent) ?? null },
+            agent: { identity: entry.agent, name: entry.agentName },
             name: entry.name,
             created: entry.created,
             finished: entry.finished,
@@ -350,25 +369,103 @@ export function createConversationStore(deps) {
             started: lives.get(entry.conversation)?.turn?.started ?? null,
         }));
     }
+    function keepList() {
+        if (!listKnown || listKept)
+            return;
+        listKept = true;
+        queueMicrotask(() => {
+            listKept = false;
+            if (deps.closed())
+                return;
+            const entries = [...listing.values()];
+            const cursor = listCursor;
+            void deps
+                .durably(async (local) => {
+                await local.fact('conversationList', entries);
+                await local.fact('conversationCursor', cursor);
+            })
+                .catch(() => { });
+        });
+    }
+    function listed(entry) {
+        const ended = listing.get(entry.conversation)?.processEnded ?? null;
+        listing.set(entry.conversation, { ...entry });
+        creations.delete(entry.conversation);
+        if (entry.processEnded !== ended)
+            emit(entry.conversation);
+    }
     function emitList() {
-        if (deps.closed() || listWatchers.size === 0)
+        if (deps.closed())
             return;
-        const value = entries();
-        for (const watcher of listWatchers)
-            watcher(value);
+        if (listWatchers.size > 0) {
+            const value = entries();
+            for (const watcher of listWatchers)
+                watcher(value);
+        }
+        emitAgents();
+        learned();
+    }
+    function learned() {
+        if (deps.closed())
+            return;
+        if (!listKnown && !listHeld && deps.stream() !== undefined && deps.online())
+            return;
+        if (unlisted.size > 0) {
+            const value = entries();
+            for (const watcher of [...unlisted]) {
+                unlisted.delete(watcher);
+                listWatchers.add(watcher);
+                watcher(value);
+            }
+        }
+        if (unnamed.size > 0) {
+            const value = agents();
+            for (const watcher of [...unnamed]) {
+                unnamed.delete(watcher);
+                agentWatchers.add(watcher);
+                watcher(value);
+            }
+        }
     }
     function agents() {
-        return [...agentNames]
-            .filter(([identity]) => !retiredAgents.has(identity))
-            .map(([identity, name]) => ({ identity, name }))
+        const named = new Map();
+        for (const agent of listedAgents ?? [])
+            named.set(agent.agent, agent);
+        for (const entry of listing.values()) {
+            named.set(entry.agent, { name: entry.agentName, retired: entry.agentRetired });
+        }
+        return [...named]
+            .filter(([, agent]) => !agent.retired)
+            .map(([identity, agent]) => ({ identity, name: agent.name }))
             .sort((left, right) => left.name === right.name
             ? left.identity.localeCompare(right.identity)
             : left.name.localeCompare(right.name));
     }
+    function readAgents() {
+        const stream = deps.stream();
+        if (stream?.agents === undefined || !deps.online() || agentsReading)
+            return;
+        agentsReading = true;
+        void stream
+            .agents()
+            .then((read) => {
+            if (read === null)
+                return;
+            listedAgents = read;
+            emitAgents();
+        }, () => { })
+            .finally(() => {
+            agentsReading = false;
+        });
+    }
     function emitAgents() {
         if (deps.closed() || agentWatchers.size === 0)
             return;
         const value = agents();
+        const shown = JSON.stringify(value);
+        if (shown === agentsShown)
+            return;
+        agentsShown = shown;
         for (const watcher of agentWatchers)
             watcher(value);
     }
@@ -384,55 +481,11 @@ export function createConversationStore(deps) {
         if (stateOf(conversation) !== before || next?.turn?.started !== began)
             emitList();
     }
-    async function readAgents() {
-        const declaration = deps.agents();
-        if (declaration === undefined)
-            return;
-        const names = new Map();
-        const retired = new Set();
-        let covered = null;
-        for (let after;;) {
-            const read = await deps.documents(declaration, after);
-            if ('pending' in read)
-                return;
-            const coverage = JSON.stringify(read.coverage);
-            if (covered !== null && coverage !== covered)
-                return readAgents();
-            covered = coverage;
-            for (const document of read.documents) {
-                const identity = document.fields?.[declaration.identity];
-                const name = document.fields?.[declaration.name];
-                if (typeof identity !== 'string' || typeof name !== 'string')
-                    continue;
-                names.set(identity, name);
-                const ended = declaration.retired === undefined ? null : document.fields?.[declaration.retired];
-                if (ended !== undefined && ended !== null)
-                    retired.add(identity);
-            }
-            if (read.next === undefined)
-                break;
-            after = read.next;
-        }
-        const named = JSON.stringify([...names]) !== JSON.stringify([...agentNames]);
-        if (!named && JSON.stringify([...retired]) === JSON.stringify([...retiredAgents]))
-            return;
-        agentNames = names;
-        retiredAgents = retired;
-        if (named)
-            emitList();
-        emitAgents();
-        const ended = [...drafts.keys()].filter(retiredChat);
-        if (ended.length > 0)
-            await remove(ended);
-    }
     function retiredChat(conversation) {
-        return (conversation.startsWith(NEW_CHAT) && retiredAgents.has(conversation.slice(NEW_CHAT.length)));
-    }
-    function agentsReady() {
-        agentsRead ??= readAgents().catch(() => {
-            agentsRead = null;
-        });
-        return agentsRead;
+        if (!conversation.startsWith(NEW_CHAT))
+            return false;
+        const agent = conversation.slice(NEW_CHAT.length);
+        return [...listing.values()].some((entry) => entry.agent === agent && entry.agentRetired);
     }
     function live(conversation, change) {
         const owed = unsent.get(conversation);
@@ -455,6 +508,7 @@ export function createConversationStore(deps) {
                 commands: facts.has('commands') ? QUIET.commands : held.commands,
                 options: facts.has('options') ? QUIET.options : held.options,
                 starting: facts.has('starting') ? QUIET.starting : held.starting,
+                subagents: facts.has('subagents') ? QUIET.subagents : held.subagents,
                 link: facts.has('link') ? QUIET.link : held.link,
                 deliveryUnknown: facts.has('deliveryUnknown')
                     ? QUIET.deliveryUnknown
@@ -508,6 +562,20 @@ export function createConversationStore(deps) {
                 deps.publish(conversationChangeSet(changed));
         });
     }
+    function missed(conversation) {
+        const read = reads.get(conversation);
+        const newest = listing.get(conversation)?.newest;
+        return (read === undefined ||
+            newest === undefined ||
+            partials.has(conversation) ||
+            (newest !== null && (read === null || newest > read)));
+    }
+    function noted(conversation, message) {
+        const entry = listing.get(conversation);
+        if (entry === undefined || (entry.newest !== null && entry.newest >= message.position))
+            return;
+        listing.set(conversation, { ...entry, newest: message.position });
+    }
     function gap(conversation) {
         gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
         behind.add(conversation);
@@ -542,7 +610,7 @@ export function createConversationStore(deps) {
         }));
         while (waiting.length > 0) {
             const asking = waiting.slice(0, HISTORY_CONVERSATIONS);
-            const result = await deps.call('conversation.history', {
+            const result = await deps.history({
                 conversations: asking.map(({ conversation, after }) => ({
                     conversation,
                     ...(after === undefined ? {} : { after }),
@@ -645,6 +713,10 @@ export function createConversationStore(deps) {
             live(conversation, { starting: event.step });
             return;
         }
+        if (event.kind === 'subagents') {
+            live(conversation, { subagents: structuredClone(event.subagents) });
+            return;
+        }
         if (event.kind === 'link') {
             live(conversation, { link: { connected: event.connected } });
             return;
@@ -656,6 +728,7 @@ export function createConversationStore(deps) {
         const arriving = acceptedMessage(event.message);
         if (arriving === null)
             return;
+        noted(conversation, arriving);
         if (replicated.has(conversation)) {
             if (deps.full()) {
                 gap(conversation);
@@ -693,7 +766,7 @@ export function createConversationStore(deps) {
         const from = newChat(agent);
         return deps.durably(async (local) => {
             const held = drafts.get(from);
-            const earlier = (held?.moves ?? []).filter((one) => !deps.expired(one));
+            const earlier = held?.moves ?? [];
             if (earlier.includes(operation))
                 return;
             const blank = {
@@ -722,10 +795,8 @@ export function createConversationStore(deps) {
     }
     async function submitted(conversation, operation, draft) {
         let submission;
-        let earlier = false;
         await withDraft(conversation, (current) => {
             submission = current?.submitted?.find((one) => one.operation === operation);
-            earlier = submission !== undefined;
             if (submission !== undefined)
                 return undefined;
             const said = draft ?? current;
@@ -738,23 +809,15 @@ export function createConversationStore(deps) {
                 submitted: [...(current?.submitted ?? []), submission],
             };
         });
-        return { submission: submission, earlier };
-    }
-    function forgotten(conversation, submission) {
-        return withDraft(conversation, (current) => {
-            const held = current?.submitted ?? [];
-            if (current === undefined || !held.includes(submission))
-                return undefined;
-            return withSubmitted(current, held.filter((one) => one !== submission));
-        });
+        return submission;
     }
     async function dispatched(conversation, submission) {
         const dispatch = { answered: false };
         sending.set(submission.operation, dispatch);
         try {
-            const result = await invoke('conversation.send', conversation, {
-                text: submission.text,
+            const result = await invoke('conversations/send', conversation, {
                 operation_id: submission.operation,
+                text: submission.text,
             });
             dispatch.answered = result.kind !== 'transport-uncertainty';
             if (result.kind === 'revoked-authorization')
@@ -763,7 +826,7 @@ export function createConversationStore(deps) {
                 deps.unanswered();
                 return result;
             }
-            const turn = answered(result, 'turn');
+            const turn = answered(result, 'message_id');
             await withDraft(conversation, async (current, local) => {
                 const held = current?.submitted?.find((one) => one.operation === submission.operation);
                 if (current === undefined || held === undefined || held.turn !== null)
@@ -783,25 +846,34 @@ export function createConversationStore(deps) {
                 sending.delete(submission.operation);
         }
     }
-    function invoke(name, conversation, extra = {}) {
-        return deps.call(name, { conversation, ...extra });
+    function invoke(name, conversation, extra = { operation_id: changeBatchIdentity() }) {
+        return deps.call(name, { conversation_id: conversation, ...extra });
     }
     const surface = {
-        async list() {
-            await agentsReady();
-            return entries();
+        list() {
+            return new Promise((settle) => {
+                const answer = (listed) => {
+                    unlisted.delete(answer);
+                    listWatchers.delete(answer);
+                    settle(listed);
+                };
+                unlisted.add(answer);
+                learned();
+            });
         },
         async read(conversation, options = {}) {
-            const asked = askedOf(options);
+            const { text, ...windowed } = options;
+            const asked = askedOf(windowed);
+            const phrase = phraseOf(text);
             return deps.durably(async (local) => {
-                const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
-                const total = asked.total ? await local.messageCount(conversation) : null;
+                const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before, phrase);
+                const total = asked.total ? await local.messageCount(conversation, phrase) : null;
                 return structuredClone(viewOf(conversation, messages, frameOf(asked, messages, more, total)));
             });
         },
         async create(input) {
-            const result = await deps.call('conversation.create', input);
-            const conversation = answered(result, 'conversation');
+            const result = await deps.call('conversations/create', input);
+            const conversation = answered(result, 'conversation_id');
             if (conversation === null)
                 return result;
             if (!listing.has(conversation))
@@ -822,11 +894,7 @@ export function createConversationStore(deps) {
                 });
                 if (held === null)
                     return DURABLE_WRITE;
-                const { submission, earlier } = held;
-                if (!earlier || !deps.expired(operation))
-                    return dispatched(conversation, submission);
-                await forgotten(conversation, submission);
-                return EXPIRED;
+                return dispatched(conversation, held);
             }
             if (draft !== undefined) {
                 await withDraft(conversation, (current) => current?.submitted?.some((one) => one.operation === operation) === true
@@ -836,28 +904,19 @@ export function createConversationStore(deps) {
             return OFFLINE;
         },
         answer(conversation, answer) {
-            return invoke('conversation.answer', conversation, { answer });
+            return invoke('conversations/interaction/answer', conversation, {
+                operation_id: changeBatchIdentity(),
+                ...answer,
+            });
         },
         interrupt(conversation) {
-            return invoke('conversation.interrupt', conversation);
+            return invoke('conversations/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) => {
-                const held = current?.submitted?.find((one) => one.turn === turn);
-                if (current === undefined || held === undefined)
-                    return undefined;
-                return returned(current, held, current.submitted.filter((one) => one !== held));
-            });
-            return result;
+            return invoke('conversations/kill', conversation);
         },
         delete(conversation) {
-            return invoke('conversation.delete', conversation);
+            return invoke('conversations/delete', conversation);
         },
     };
     const chatDraft = {
@@ -886,7 +945,15 @@ export function createConversationStore(deps) {
     return {
         surface,
         chatDraft,
-        hydrate(held, kept) {
+        hydrate(held, kept, list, cursor) {
+            if (list !== null && !listKnown) {
+                listing.clear();
+                for (const entry of list)
+                    listing.set(entry.conversation, { ...entry });
+                listHeld = true;
+                listCursor = cursor;
+                deps.stream()?.hold(cursor);
+            }
             stored.clear();
             reads.clear();
             partials.clear();
@@ -900,6 +967,8 @@ export function createConversationStore(deps) {
             drafts.clear();
             for (const record of kept)
                 drafts.set(record.conversation, record);
+            if (listHeld)
+                learned();
         },
         async reconcile() {
             if (!listKnown)
@@ -911,7 +980,7 @@ export function createConversationStore(deps) {
                 !creations.has(conversation) &&
                 (!conversation.startsWith(NEW_CHAT) || retiredChat(conversation)));
             for (const conversation of named) {
-                if (!replicated.has(conversation))
+                if (!replicated.has(conversation) && missed(conversation))
                     behind.add(conversation);
             }
             replicated = named;
@@ -949,10 +1018,6 @@ export function createConversationStore(deps) {
                         continue;
                     if (deps.closed())
                         return;
-                    if (deps.expired(submission.operation)) {
-                        await forgotten(conversation, submission);
-                        continue;
-                    }
                     const result = await dispatched(conversation, submission);
                     if (result.kind === 'revoked-authorization')
                         return;
@@ -973,11 +1038,8 @@ export function createConversationStore(deps) {
         known() {
             return listKnown;
         },
-        reconnected() {
-            for (const conversation of replicated)
-                gap(conversation);
-        },
         reopened() {
+            relisting = null;
             for (const [operation, dispatch] of sending)
                 if (!dispatch.answered)
                     sending.delete(operation);
@@ -999,15 +1061,15 @@ export function createConversationStore(deps) {
             views.set(key, view);
             const watcher = { notify: deliver, ready: false };
             view.watchers.add(watcher);
-            void deps
-                .durably(async (local) => {
+            const reading = new AbortController();
+            void untilAnswered(() => deps.durably(async (local) => {
                 if (view.window !== null)
                     return;
                 const { messages, more } = await local.messageWindow(conversation, asked.limit, asked.before);
                 view.window = messages;
                 view.more = more;
                 view.total = asked.total ? await local.messageCount(conversation) : null;
-            })
+            }), reading.signal)
                 .then(() => {
                 if (deps.closed() || !view.watchers.has(watcher))
                     return;
@@ -1017,6 +1079,7 @@ export function createConversationStore(deps) {
             })
                 .catch(() => { });
             return () => {
+                reading.abort();
                 if (!view.watchers.delete(watcher))
                     return;
                 if (view.watchers.size === 0)
@@ -1024,77 +1087,88 @@ export function createConversationStore(deps) {
             };
         },
         watchList(deliver) {
-            listWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && listWatchers.has(deliver))
-                    deliver(entries());
-            });
+            unlisted.add(deliver);
+            learned();
             return () => {
+                unlisted.delete(deliver);
                 listWatchers.delete(deliver);
             };
         },
         watchAgents(deliver) {
-            agentWatchers.add(deliver);
-            void agentsReady().then(() => {
-                if (!deps.closed() && agentWatchers.has(deliver))
-                    deliver(agents());
-            });
+            unnamed.add(deliver);
+            learned();
+            readAgents();
             return () => {
+                unnamed.delete(deliver);
                 agentWatchers.delete(deliver);
             };
         },
+        learned,
         changed(set) {
             for (const conversation of set.conversations)
                 emit(conversation);
-            const declaration = deps.agents();
-            if (declaration !== undefined &&
-                set.documents.some((change) => change.locator === declaration.locator)) {
-                agentsRead = readAgents().catch(() => {
-                    agentsRead = null;
-                });
-            }
         },
         receive(event) {
             if (deps.closed())
                 return false;
             if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted') {
                 if (event.kind === 'list') {
-                    listing.clear();
+                    if (event.whole)
+                        relisting ??= new Map();
                     for (const entry of event.entries) {
-                        listing.set(entry.conversation, { ...entry });
-                        creations.delete(entry.conversation);
+                        if (relisting === null)
+                            listed(entry);
+                        else
+                            relisting.set(entry.conversation, { ...entry });
+                    }
+                    if (event.more)
+                        return false;
+                    if (relisting !== null) {
+                        listing.clear();
+                        for (const entry of relisting.values())
+                            listed(entry);
+                        relisting = null;
                     }
+                    listCursor = event.cursor;
+                    deps.stream()?.hold(event.cursor);
                     listKnown = true;
+                    for (const conversation of replicated) {
+                        if (!listing.has(conversation))
+                            continue;
+                        if (!missed(conversation))
+                            behind.delete(conversation);
+                        else if (!behind.has(conversation))
+                            gap(conversation);
+                    }
                     openingEnded();
                 }
                 else if (event.kind === 'listed') {
-                    listing.set(event.entry.conversation, { ...event.entry });
-                    creations.delete(event.entry.conversation);
+                    listed(event.entry);
+                    relisting?.set(event.entry.conversation, { ...event.entry });
                 }
                 else {
                     listing.delete(event.conversation);
+                    relisting?.delete(event.conversation);
                 }
+                keepList();
                 emitList();
-                return (event.kind !== 'list' &&
+                return ((event.kind !== 'list' &&
                     listKnown &&
                     (listing.size !== replicated.size ||
-                        [...listing.keys()].some((conversation) => !replicated.has(conversation))));
+                        [...listing.keys()].some((conversation) => !replicated.has(conversation)))) ||
+                    (listKnown && [...drafts.keys()].some(retiredChat)));
             }
             heard(event);
             return false;
         },
-        searchable() {
-            return [...(listKnown ? listing.keys() : stored)].sort();
-        },
-        acquired(conversation) {
-            return reads.has(conversation) && !partials.has(conversation);
-        },
         close() {
             views.clear();
             lives.clear();
             unsent.clear();
             listWatchers.clear();
+            unlisted.clear();
             agentWatchers.clear();
+            unnamed.clear();
         },
     };
 }