@agentshouse/mdruntime-adapter 0.1.0-cfd03209dcd82 → 0.1.0-cfd2dc1938a2c

package/dist/stream.js

@@ -1,47 +1,129 @@
-import { acceptedMessage } from './actions.js';
-import { binaryFileOf, headChange } from './read.js';
-import { roomVersion } from './version.js';
-const HELD_FRAMES_MAX = 256;
+import { ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
+import { acceptedMessage, cursorPosition, houseHistory } from './history.js';
+import { keptSpaceSchemas, streamedModels } from './model.js';
+import { answered, answering, binaryFileOf, createdOf, folded, forgotten, headChange, revised, } from './read.js';
+import { classifyDoor } from './refusal.js';
+import { houseDoorRoute, } from './transport.js';
+import { DECIMAL, logPosition, presented, roomVersion } from './version.js';
 function turnOperation(frame) {
     const { type: _type, conversation_id: _conversation, turn_id: _turn, ...operation } = frame;
     return structuredClone(operation);
 }
+async function houseAgents(transport) {
+    const answer = await transport.door(houseDoorRoute('agents/list'), {});
+    if (classifyDoor(answer.status, answer.body, 'agents/list')?.kind === 'transport-uncertainty') {
+        throw new Error('agents/list reached no answer');
+    }
+    const agents = answer.status === 200 ? answer.body?.agents : null;
+    if (!Array.isArray(agents))
+        return null;
+    return agents.flatMap((one) => {
+        const { id, name, retired_at: retired } = (one ?? {});
+        return typeof id === 'string' && typeof name === 'string'
+            ? [{ agent: id, name, retired: retired !== null && retired !== undefined }]
+            : [];
+    });
+}
 function listedConversation(listed) {
     return {
         conversation: listed.conversation_id,
         agent: listed.agent_id,
+        agentName: listed.agent_name,
+        agentRetired: listed.agent_retired,
         name: listed.name,
         created: listed.created_at,
         finished: listed.finished_at,
         outcome: listed.outcome,
+        waiting: listed.waiting,
+        newest: listed.newest === null ? null : cursorPosition(listed.newest),
+        processEnded: listed.process_ended_at,
     };
 }
 function position(value) {
-    if (!/^(?:0|[1-9][0-9]*)$/.test(value))
+    if (!DECIMAL.test(value))
         return null;
     return BigInt(value);
 }
-export function houseNotifications(transport, mode) {
+function* changed(tracked, entries, version, schemas) {
+    const answer = answering();
+    for (const entry of entries) {
+        yield ROW_WEIGHT + (entry.text?.length ?? 0);
+        if (entry.kind === 'folder') {
+            folded(answer, entry.path, entry.removed === true);
+            continue;
+        }
+        if (entry.path === tracked.schema)
+            schemas.set(entry.path, entry);
+        forgotten(answer, entry.path);
+        if (entry.space !== undefined) {
+            answer.removals.add(entry.path);
+            continue;
+        }
+        if (entry.kind === 'removed') {
+            answer.removals.add(entry.path);
+            continue;
+        }
+        const binary = binaryFileOf(entry);
+        if (binary === undefined)
+            answer.documents.set(entry.path, entry.text ?? '');
+        else if (binary !== null)
+            answer.binaryFiles.set(entry.path, binary);
+        if (binary === undefined && entry.facts !== undefined)
+            answer.facts.set(entry.path, entry.facts);
+        const revision = entry.revision ?? binary?.sha256;
+        if (revision !== undefined)
+            revised(answer, entry.path, revision);
+        const head = headChange(entry);
+        if (head)
+            answer.changes.set(entry.path, head);
+        const created = createdOf(entry);
+        if (created)
+            answer.created.set(entry.path, created);
+    }
+    return { kind: 'net-advancement', roomVersion: version, ...(yield* answered(answer)) };
+}
+async function changePage(tracked, entries, version, mode, spaces, whole) {
+    const schemas = new Map();
+    const page = await stepped(changed(tracked, entries, version, schemas));
+    const models = await streamedModels(schemas, tracked, mode, spaces, whole);
+    return models === undefined ? page : { ...page, models };
+}
+export function houseNotifications(transport, mode, discovering, spaces) {
     const stream = transport.stream;
-    const lines = new Map();
-    const locators = new Map();
+    const staged = new Map();
+    let socket = null;
+    const tracking = new Map();
     const observers = new Set();
+    const replaying = new Map();
     const conversationObservers = new Set();
     const modeObservers = new Set();
     let replicated = [];
+    let listedCursor = null;
+    const unanswered = [];
+    const heldAtZero = new Set();
     const live = new Set();
     let opening = null;
+    let announced = null;
     const runtime = crypto.randomUUID();
     function emit(event) {
-        for (const observer of observers)
-            observer(event);
+        for (const observer of observers) {
+            const held = replaying.get(observer);
+            if (held === undefined)
+                observer(event);
+            else
+                held.push(event);
+        }
     }
     function emitConversation(event) {
         if (event.kind === 'turn' ||
             event.kind === 'questions' ||
             event.kind === 'process' ||
             event.kind === 'commands' ||
-            event.kind === 'options') {
+            event.kind === 'options' ||
+            event.kind === 'starting' ||
+            event.kind === 'subagents' ||
+            event.kind === 'link' ||
+            event.kind === 'deliveries') {
             live.add(event.conversation);
         }
         for (const observer of conversationObservers)
@@ -49,11 +131,33 @@ export function houseNotifications(transport, mode) {
     }
     function reopened(next) {
         opening = next;
+        announced = null;
+        socket = next;
+        staged.clear();
+        unanswered.length = 0;
+        heldAtZero.clear();
         const gapped = new Set([...replicated, ...live]);
         live.clear();
         for (const conversation of gapped)
             emitConversation({ kind: 'gap', conversation });
         emit({ kind: 'opened' });
+        if (mode === 'site')
+            announce(next, null);
+    }
+    function announce(via, frame) {
+        void discovering.opened(frame).then((discovery) => {
+            if (socket !== via)
+                return;
+            if (discovery === null) {
+                via.close();
+                return;
+            }
+            announced = { kind: 'discovered', discovery };
+            emit(announced);
+        }, () => {
+            if (socket === via)
+                via.close();
+        });
     }
     function converse(frame) {
         const conversation = frame.conversation_id;
@@ -72,6 +176,7 @@ export function houseNotifications(transport, mode) {
                 return;
             emitConversation({ kind: 'commands', conversation, commands: [] });
             emitConversation({ kind: 'options', conversation, options: [] });
+            emitConversation({ kind: 'subagents', conversation, subagents: [] });
             return;
         }
         if (frame.type === 'commands') {
@@ -86,6 +191,26 @@ export function houseNotifications(transport, mode) {
             emitConversation({ kind: 'options', conversation, options: structuredClone(frame.options) });
             return;
         }
+        if (frame.type === 'starting') {
+            emitConversation({ kind: 'starting', conversation, step: frame.step });
+            return;
+        }
+        if (frame.type === 'subagents') {
+            emitConversation({
+                kind: 'subagents',
+                conversation,
+                subagents: structuredClone(frame.subagents),
+            });
+            return;
+        }
+        if (frame.type === 'link') {
+            emitConversation({ kind: 'link', conversation, connected: frame.connected });
+            return;
+        }
+        if (frame.type === 'deliveries') {
+            emitConversation({ kind: 'deliveries', conversation, unknown: [...frame.unknown] });
+            return;
+        }
         if (frame.type === 'interactions') {
             emitConversation({
                 kind: 'questions',
@@ -99,18 +224,33 @@ export function houseNotifications(transport, mode) {
             return;
         emitConversation({ kind: 'accepted-message', conversation, message });
     }
-    function announce(authority, at) {
-        const version = roomVersion(at);
-        for (const locator of locators.get(authority) ?? []) {
-            emit({ kind: 'room-version', locator, roomVersion: version });
+    function stage(frame, via) {
+        const held = staged.get(frame.carry);
+        if (frame.index !== (held?.parts ?? 0)) {
+            staged.delete(frame.carry);
+            return;
+        }
+        if (held === undefined) {
+            for (const [carry, other] of staged) {
+                if (other.authority === frame.authority)
+                    staged.delete(carry);
+            }
         }
+        const next = held ?? { authority: frame.authority, parts: 0, entries: [] };
+        keptSpaceSchemas(frame.entries, spaces);
+        next.entries.push(...frame.entries);
+        next.parts += 1;
+        staged.set(frame.carry, next);
+        via?.received(frame.authority, frame.carry, frame.index);
     }
-    function interrupt(authority) {
-        const line = lines.get(authority);
-        if (line !== undefined)
-            lines.set(authority, { ...line, frames: [] });
+    function carried(frame) {
+        const held = staged.get(frame.carry);
+        staged.delete(frame.carry);
+        if ((held?.parts ?? 0) !== frame.parts)
+            return;
+        publish(frame, held?.entries ?? []);
     }
-    function receive(frame) {
+    function handle(frame, via) {
         if (frame.type === 'signal') {
             const mode = frame.service_mode;
             if (mode !== 'open' && mode !== 'write-halted')
@@ -120,14 +260,35 @@ export function houseNotifications(transport, mode) {
             return;
         }
         if (frame.type === 'opening') {
+            if (via !== null && mode === 'credential')
+                announce(via, frame);
+            return;
+        }
+        if (frame.type === 'caught_up') {
+            discovering.expired?.(frame.expired);
             emit({
-                kind: 'opening',
-                expired: frame.expired.flatMap((authority) => locators.get(authority) ?? []),
+                kind: 'caught-up',
+                expired: [
+                    ...frame.expired.flatMap((authority) => (tracking.get(authority) ?? []).map((tracked) => tracked.locator)),
+                    ...(unanswered.shift() ?? []),
+                ],
             });
             return;
         }
+        if (frame.type === 'authority_changed') {
+            const change = discovering.changed(frame);
+            if (change !== null)
+                emit(change);
+            return;
+        }
         if (frame.type === 'conversations') {
-            emitConversation({ kind: 'list', entries: frame.conversations.map(listedConversation) });
+            emitConversation({
+                kind: 'list',
+                entries: frame.conversations.map(listedConversation),
+                whole: frame.whole,
+                more: frame.more,
+                cursor: frame.cursor,
+            });
             return;
         }
         if (frame.type === 'conversation') {
@@ -142,40 +303,49 @@ export function houseNotifications(transport, mode) {
             frame.type === 'process' ||
             frame.type === 'commands' ||
             frame.type === 'options' ||
+            frame.type === 'starting' ||
+            frame.type === 'subagents' ||
+            frame.type === 'link' ||
+            frame.type === 'deliveries' ||
             frame.type === 'interactions' ||
             frame.type === 'message') {
             converse(frame);
             return;
         }
-        if (frame.type !== 'entries')
-            return;
+        if (frame.type === 'part')
+            stage(frame, via);
+        else if (frame.type === 'carried')
+            carried(frame);
+    }
+    function publish(frame, entries) {
         const at = position(frame.position);
         const after = position(frame.after);
-        if (at === null || after === null || after >= at) {
-            interrupt(frame.authority);
+        if (at === null || after === null || after >= at)
             return;
+        const from = after === 0n && !heldAtZero.has(frame.authority)
+            ? null
+            : roomVersion({ position: frame.after, logEpoch: frame.log_epoch });
+        const version = roomVersion({ position: frame.position, logEpoch: frame.log_epoch });
+        for (const tracked of tracking.get(frame.authority) ?? []) {
+            emit({
+                kind: 'room-change',
+                locator: tracked.locator,
+                from,
+                roomVersion: version,
+                read: () => changePage(tracked, entries, version, mode, spaces, from === null),
+            });
         }
-        const line = lines.get(frame.authority);
-        if (line?.logEpoch === frame.log_epoch) {
-            if (line.held !== null && at <= line.held)
-                return;
-            const last = line.frames.at(-1);
-            if (last !== undefined && at <= last.position)
-                return;
-            const held = { after, position: at, entries: frame.entries };
-            const next = last !== undefined && after <= last.position ? [...line.frames, held] : [held];
-            lines.set(frame.authority, { ...line, frames: next.length > HELD_FRAMES_MAX ? [] : next });
-        }
-        else {
-            interrupt(frame.authority);
-        }
-        announce(frame.authority, { position: frame.position, logEpoch: frame.log_epoch });
     }
-    stream.observe(receive);
+    stream.observe((frame) => handle(frame, socket));
     stream.opened(reopened);
-    stream.closed((revoked) => {
+    stream.closed(({ revoked, lost, authorityChanged }) => {
         opening = null;
-        emit({ kind: 'closed', revoked });
+        announced = null;
+        socket = null;
+        staged.clear();
+        unanswered.length = 0;
+        heldAtZero.clear();
+        emit({ kind: 'closed', revoked, lost, authorityChanged });
     });
     return {
         runtime,
@@ -191,19 +361,34 @@ export function houseNotifications(transport, mode) {
             replicate(next) {
                 replicated = [...next];
             },
+            hold(cursor) {
+                listedCursor = cursor;
+            },
             observe(notify) {
                 conversationObservers.add(notify);
                 return () => {
                     conversationObservers.delete(notify);
                 };
             },
+            ...(mode === 'credential'
+                ? {
+                    agents: () => houseAgents(transport),
+                    history: (request) => houseHistory(transport, request),
+                }
+                : {}),
         },
         observe(notify) {
             observers.add(notify);
             if (opening !== null) {
+                const replayed = [{ kind: 'opened' }];
+                if (announced !== null)
+                    replayed.push(announced);
+                replaying.set(notify, replayed);
                 queueMicrotask(() => {
-                    if (observers.has(notify))
-                        notify({ kind: 'opened' });
+                    replaying.delete(notify);
+                    for (const event of replayed)
+                        if (observers.has(notify))
+                            notify(event);
                 });
             }
             return () => {
@@ -211,124 +396,59 @@ export function houseNotifications(transport, mode) {
             };
         },
         send(rooms) {
-            for (const room of rooms) {
-                const line = lines.get(room.authority);
-                const held = position(room.position);
-                if (line === undefined || held === null || line.logEpoch !== room.log_epoch)
-                    continue;
-                lines.set(room.authority, { ...line, frames: [], held });
-            }
-            const current = opening;
-            opening = null;
-            current?.hold(rooms, runtime);
-        },
-        reopen() {
-            const current = opening;
             opening = null;
-            current?.close();
-        },
-        track(entries) {
-            locators.clear();
-            for (const entry of entries) {
-                locators.set(entry.authority, [...(locators.get(entry.authority) ?? []), entry.locator]);
-                if (lines.get(entry.authority)?.logEpoch !== entry.logEpoch) {
-                    lines.set(entry.authority, { logEpoch: entry.logEpoch, frames: [], held: null });
-                }
-            }
-            for (const authority of lines.keys()) {
-                if (!locators.has(authority))
-                    lines.delete(authority);
-            }
-        },
-        reach(authority, at) {
-            const line = lines.get(authority);
-            const held = position(at.position);
-            if (line === undefined || held === null || line.logEpoch !== at.logEpoch)
+            announced = null;
+            if (socket === null)
                 return;
-            if (line.held !== null && held <= line.held)
+            const entries = new Map([...tracking.values()].flat().map((tracked) => [tracked.locator, tracked]));
+            const named = rooms.flatMap((room) => {
+                const entry = entries.get(room.locator);
+                const at = room.roomVersion === null ? null : logPosition(room.roomVersion);
+                return entry === undefined || at === null ? [] : [{ entry, at }];
+            });
+            const unheld = rooms.flatMap((room) => {
+                const entry = entries.get(room.locator);
+                return entry === undefined || room.roomVersion !== null ? [] : [entry];
+            });
+            for (const { entry, at } of named) {
+                if (at.position === '0')
+                    heldAtZero.add(entry.authority);
+                else
+                    heldAtZero.delete(entry.authority);
+            }
+            for (const entry of unheld)
+                heldAtZero.delete(entry.authority);
+            const site = mode === 'site';
+            unanswered.push(site ? unheld.map((entry) => entry.locator) : []);
+            socket.hold([
+                ...named.map(({ entry, at }) => presented(entry.authority, at)),
+                ...(site ? [] : unheld).map((entry) => presented(entry.authority, { position: '0', logEpoch: entry.logEpoch })),
+            ], runtime, listedCursor);
+            if (site)
                 return;
-            lines.set(authority, {
-                ...line,
-                frames: line.frames.filter((frame) => frame.position > held),
-                held,
+            const made = unheld.filter((entry) => entry.position === '0');
+            queueMicrotask(() => {
+                for (const entry of made) {
+                    const version = roomVersion(entry);
+                    emit({
+                        kind: 'room-change',
+                        locator: entry.locator,
+                        from: null,
+                        roomVersion: version,
+                        read: () => changePage(entry, [], version, mode, spaces, true),
+                    });
+                }
             });
         },
-        advance(tracked, from, holds) {
-            const line = lines.get(tracked.authority);
-            const start = position(from.position);
-            if (line === undefined || start === null || line.logEpoch !== from.logEpoch)
-                return null;
-            const pending = line.frames.filter((frame) => frame.position > start);
-            const first = pending[0];
-            if (first === undefined || first.after > start)
-                return null;
-            const documents = {};
-            const revisions = {};
-            const changes = {};
-            const binaryFiles = {};
-            const removals = [];
-            const applied = [];
-            const schemas = new Map();
-            const forget = (path) => {
-                delete documents[path];
-                delete revisions[path];
-                delete changes[path];
-                delete binaryFiles[path];
-                const removed = removals.indexOf(path);
-                if (removed !== -1)
-                    removals.splice(removed, 1);
-            };
-            for (const frame of pending) {
-                for (const entry of frame.entries) {
-                    if (entry.kind === 'edited' &&
-                        entry.revision !== undefined &&
-                        holds?.(entry.path, entry.revision) === true) {
-                        forget(entry.path);
-                        continue;
-                    }
-                    applied.push(entry);
-                    if (tracked.schemas.includes(entry.path))
-                        schemas.set(entry.path, entry);
-                    if (entry.kind === 'removed') {
-                        forget(entry.path);
-                        removals.push(entry.path);
-                        continue;
-                    }
-                    const binary = binaryFileOf(entry);
-                    if (binary === null || (binary === undefined && entry.text === undefined))
-                        return null;
-                    if (mode === 'credential' && entry.revision === undefined)
-                        return null;
-                    const head = headChange(entry);
-                    if (head === null)
-                        return null;
-                    forget(entry.path);
-                    if (binary === undefined)
-                        documents[entry.path] = entry.text;
-                    else
-                        binaryFiles[entry.path] = binary;
-                    const revision = entry.revision ?? binary?.sha256;
-                    if (revision !== undefined)
-                        revisions[entry.path] = revision;
-                    if (head !== undefined)
-                        changes[entry.path] = head;
-                }
+        track(entries) {
+            tracking.clear();
+            for (const entry of entries) {
+                tracking.set(entry.authority, [...(tracking.get(entry.authority) ?? []), entry]);
+            }
+            for (const [carry, held] of staged) {
+                if (!tracking.has(held.authority))
+                    staged.delete(carry);
             }
-            const last = pending.at(-1);
-            lines.set(tracked.authority, { ...line, frames: pending, held: last.position });
-            return {
-                page: {
-                    kind: 'net-advancement',
-                    roomVersion: roomVersion({ position: last.position.toString(), logEpoch: line.logEpoch }),
-                    documents,
-                    revisions,
-                    changes,
-                    binaryFiles,
-                    removals: removals.sort(),
-                },
-                entries: applied,
-                schemas,
-            };
         },
     };
 }