@agentshouse/mdruntime-adapter 0.1.0-cc63dd043d0e2 → 0.1.0-cc7da2d4669a3

package/dist/stream.js

@@ -1,45 +1,137 @@
-import { acceptedMessage } from './actions.js';
-import { 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 { streamedModels } from './model.js';
+import { answered, answering, binaryFileOf, folded, forgotten, headChange, revised, } from './read.js';
+import { houseDoorRoute, } from './transport.js';
+import { DECIMAL, 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/read'), {});
+    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),
+    };
+}
 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) {
-    const stream = transport.stream;
-    const lines = new Map();
-    const locators = new Map();
+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.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);
+        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);
+    }
+    return { kind: 'net-advancement', roomVersion: version, ...(yield* answered(answer)) };
+}
+async function changePage(tracked, entries, version, mode) {
     const schemas = new Map();
+    const page = await stepped(changed(tracked, entries, version, schemas));
+    const models = await streamedModels(schemas, tracked, mode);
+    return models === undefined ? page : { ...page, models };
+}
+export function houseNotifications(transport, mode, discovering) {
+    const stream = transport.stream;
+    const staged = new Map();
+    let socket = null;
+    const tracking = new Map();
     const observers = new Set();
     const conversationObservers = new Set();
     const modeObservers = new Set();
     let replicated = [];
     const live = new Set();
-    let listening = false;
-    let catching = false;
-    function listen() {
-        if (listening)
-            return;
-        listening = true;
-        stream.observe(receive);
+    let opening = null;
+    let announced = null;
+    const runtime = crypto.randomUUID();
+    function emit(event) {
+        for (const observer of observers)
+            observer(event);
     }
     function emitConversation(event) {
-        if (event.kind !== 'gap' && event.kind !== 'accepted-message')
+        if (event.kind === 'turn' ||
+            event.kind === 'questions' ||
+            event.kind === 'process' ||
+            event.kind === 'commands' ||
+            event.kind === 'options' ||
+            event.kind === 'starting' ||
+            event.kind === 'link' ||
+            event.kind === 'deliveries') {
             live.add(event.conversation);
+        }
         for (const observer of conversationObservers)
             observer(event);
     }
-    function reopened() {
+    function reopened(next) {
+        opening = next;
+        announced = null;
+        socket = next;
+        staged.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 +164,18 @@ 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 === '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',
@@ -85,22 +189,32 @@ export function houseNotifications(transport, mode) {
             return;
         emitConversation({ kind: 'accepted-message', conversation, message });
     }
-    function announce(authority, at, modelChanged) {
-        const version = roomVersion(at);
-        for (const locator of locators.get(authority) ?? []) {
-            for (const observer of observers) {
-                observer(modelChanged
-                    ? { locator, roomVersion: version, modelChanged: true }
-                    : { 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: [] };
+        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')
@@ -109,45 +223,84 @@ export function houseNotifications(transport, mode) {
                 observer(mode);
             return;
         }
+        if (frame.type === 'opening') {
+            if (via !== null && mode === 'credential')
+                announce(via, frame);
+            return;
+        }
+        if (frame.type === 'caught_up') {
+            emit({
+                kind: 'caught-up',
+                expired: frame.expired.flatMap((authority) => (tracking.get(authority) ?? []).map((tracked) => tracked.locator)),
+            });
+            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) });
+            return;
+        }
+        if (frame.type === 'conversation') {
+            emitConversation({ kind: 'listed', entry: listedConversation(frame.conversation) });
+            return;
+        }
+        if (frame.type === 'conversation_deleted') {
+            emitConversation({ kind: 'unlisted', conversation: frame.conversation_id });
+            return;
+        }
         if (frame.type === 'turn' ||
             frame.type === 'process' ||
             frame.type === 'commands' ||
             frame.type === 'options' ||
+            frame.type === 'starting' ||
+            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 = 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),
+            });
         }
-        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);
-        }
-        const addresses = schemas.get(frame.authority) ?? [];
-        announce(frame.authority, { position: frame.position, logEpoch: frame.log_epoch }, frame.entries.some((entry) => addresses.includes(entry.path)));
     }
+    stream.observe((frame) => handle(frame, socket));
+    stream.opened(reopened);
+    stream.closed(({ revoked, lost }) => {
+        opening = null;
+        announced = null;
+        socket = null;
+        staged.clear();
+        emit({ kind: 'closed', revoked, lost });
+    });
     return {
+        runtime,
         serviceMode: {
             observe(notify) {
                 modeObservers.add(notify);
-                listen();
                 return () => {
                     modeObservers.delete(notify);
                 };
@@ -159,112 +312,45 @@ export function houseNotifications(transport, mode) {
             },
             observe(notify) {
                 conversationObservers.add(notify);
-                listen();
-                if (!catching) {
-                    catching = true;
-                    stream.opened(reopened);
-                }
                 return () => {
                     conversationObservers.delete(notify);
                 };
             },
-        },
-        track(entries) {
-            locators.clear();
-            schemas.clear();
-            for (const entry of entries) {
-                locators.set(entry.authority, [...(locators.get(entry.authority) ?? []), entry.locator]);
-                schemas.set(entry.authority, entry.schemas);
-                if (lines.get(entry.authority)?.logEpoch !== entry.logEpoch) {
-                    lines.set(entry.authority, { logEpoch: entry.logEpoch, frames: [], held: null });
+            ...(mode === 'credential'
+                ? {
+                    agents: () => houseAgents(transport),
+                    history: (request) => houseHistory(transport, request),
                 }
-            }
-            for (const authority of lines.keys()) {
-                if (!locators.has(authority))
-                    lines.delete(authority);
-            }
+                : {}),
         },
-        select() { },
         observe(notify) {
             observers.add(notify);
-            listen();
+            const replayed = opening === null ? [] : [{ kind: 'opened' }, announced];
+            if (replayed.length > 0) {
+                queueMicrotask(() => {
+                    for (const event of replayed)
+                        if (event !== null && observers.has(notify))
+                            notify(event);
+                });
+            }
             return () => {
                 observers.delete(notify);
             };
         },
-        hold(authority, at) {
-            const line = lines.get(authority);
-            const held = position(at.position);
-            if (line === undefined || held === null || line.logEpoch !== at.logEpoch)
-                return;
-            lines.set(authority, { ...line, held });
+        send(rooms) {
+            opening = null;
+            announced = null;
+            socket?.hold(rooms, runtime);
         },
-        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 removals = [];
-            const applied = [];
-            const forget = (path) => {
-                delete documents[path];
-                delete revisions[path];
-                delete changes[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.text === undefined &&
-                        entry.revision !== undefined &&
-                        holds?.(entry.path, entry.revision) === true) {
-                        forget(entry.path);
-                        continue;
-                    }
-                    applied.push(entry);
-                    if (entry.kind === 'removed') {
-                        forget(entry.path);
-                        removals.push(entry.path);
-                        continue;
-                    }
-                    if (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);
-                    documents[entry.path] = entry.text;
-                    if (entry.revision !== undefined)
-                        revisions[entry.path] = entry.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,
-                    binaryTargets: [],
-                    removals: removals.sort(),
-                },
-                entries: applied,
-            };
         },
     };
 }

package/dist/transport.d.ts

@@ -1,36 +1,40 @@
 import type { ConversationEvent, TurnOperation } from '@agentshouse/mdruntime';
-export declare const DOOR_DISCOVER = "/door/discover";
-export declare const DOOR_BOOTSTRAP = "/door/bootstrap";
-export declare const DOOR_ENUMERATE = "/door/enumerate";
-export declare const DOOR_BATCH = "/door/batch";
-export declare const DOOR_BATCH_UPLOAD = "/door/batch-upload";
-export declare const DOOR_REVISIONS = "/door/revisions";
-export declare const SITE_DOOR_DISCOVER = "/_house/door/discover";
-export declare const SITE_DOOR_BOOTSTRAP = "/_house/door/bootstrap/";
-export declare const SITE_DOOR_ENUMERATE = "/_house/door/enumerate";
+export declare const HOUSE_RUNTIME_READS: {
+    readonly acts: readonly ['account/push', 'agents/read', 'apps/features/set', 'apps/source/download', 'apps/source/top', 'batch', 'batch-upload', 'bootstrap', 'conversations/history', 'discover', 'files/attach', 'files/finish', 'files/get', 'revisions', 'sites/screenshot/read'];
+    readonly frames: readonly ['app-message', 'authority_changed', 'carried', 'caught_up', 'commands', 'conversation', 'conversation_deleted', 'conversations', 'deliveries', 'deployment', 'held', 'interactions', 'link', 'message', 'opening', 'options', 'part', 'process', 'received', 'signal', 'site', 'starting', 'tab-icon', 'turn'];
+};
+export type HouseRuntimeAct = (typeof HOUSE_RUNTIME_READS.acts)[number];
+export type HouseRuntimeFrame = (typeof HOUSE_RUNTIME_READS.frames)[number];
+export declare function houseDoorRoute(act: HouseRuntimeAct): string;
+export declare function houseSiteRoute(act: Extract<HouseRuntimeAct, 'bootstrap' | 'discover'>): string;
+export declare const SITE_SUBMISSION = "site/submission";
 export declare const SITE_DOOR_SUBMIT = "/_house/door/submit";
-export declare const PRIVATE_LOCATOR = "private";
 export type HouseMode = 'credential' | 'site';
 export type HouseDoorAnswer = {
     status: number;
     body: unknown;
 };
-export type HouseByteAct = 'local_copy_bundle' | 'authored_batch_upload' | 'conversation_original_upload' | 'original_upload' | 'original_download';
-export type HouseByteBody = string | ArrayBuffer | Uint8Array;
-export type HouseByteAnswer = 'json' | 'bytes';
+export declare const SITE_FILES = "/_house/files/";
+export type HouseByteAct = 'authored_batch_upload';
+export type HouseBytesAnswer = {
+    status: number;
+    body: ReadableStream<Uint8Array> | null;
+    mediaType: string;
+};
 export type HouseByteTransfer = {
     act: HouseByteAct;
-    method: 'GET' | 'POST';
     url: string;
-    answer: HouseByteAnswer;
-    body?: HouseByteBody;
-    operation?: string;
+    body: string;
 };
 export type HouseStreamEntry = {
     path: string;
-    kind: 'edited' | 'removed';
+    kind: 'edited' | 'removed' | 'folder';
+    removed?: true;
     revision?: string;
+    sha256?: string;
     text?: string;
+    bytes?: number;
+    media_type?: string;
     author?: {
         user: string;
         name: string;
@@ -43,13 +47,52 @@ export type HouseStreamEntry = {
 type LiveFact<K extends ConversationEvent['kind']> = Extract<ConversationEvent, {
     kind: K;
 }>;
-export type HouseStreamFrame = {
-    type: 'entries';
+export type HouseListedConversation = {
+    conversation_id: string;
+    agent_id: string;
+    agent_name: string;
+    agent_retired: boolean;
+    name: string;
+    created_at: string;
+    finished_at: string | null;
+    outcome: string | null;
+    waiting: boolean;
+    newest: {
+        accepted_at: string;
+        message_id: string;
+    } | null;
+};
+type Listed<Frame extends {
+    readonly type: HouseRuntimeFrame;
+}> = Frame;
+export type HouseStreamFrame = Listed<{
+    type: 'part';
+    authority: string;
+    carry: string;
+    index: number;
+    entries: readonly HouseStreamEntry[];
+} | {
+    type: 'carried';
     authority: string;
+    carry: string;
+    parts: number;
     after: string;
     position: string;
     log_epoch: string;
-    entries: readonly HouseStreamEntry[];
+} | {
+    type: 'opening';
+    member: unknown;
+    bounds: unknown;
+    actions: readonly unknown[];
+    authorities: readonly unknown[];
+} | {
+    type: 'caught_up';
+    expired: readonly string[];
+} | {
+    type: 'authority_changed';
+    member: unknown;
+    authorities: readonly unknown[];
+    left: readonly string[];
 } | ({
     type: 'turn';
     conversation_id: string;
@@ -62,6 +105,10 @@ export type HouseStreamFrame = {
     type: 'interactions';
     conversation_id: string;
     interactions: readonly unknown[];
+} | {
+    type: 'deliveries';
+    conversation_id: string;
+    unknown: readonly string[];
 } | {
     type: 'process';
     conversation_id: string;
@@ -74,24 +121,64 @@ export type HouseStreamFrame = {
     type: 'options';
     conversation_id: string;
     options: LiveFact<'options'>['options'];
+} | {
+    type: 'starting';
+    conversation_id: string;
+    step: string | null;
+} | {
+    type: 'link';
+    conversation_id: string;
+    connected: boolean;
+} | {
+    type: 'conversations';
+    conversations: readonly HouseListedConversation[];
+} | {
+    type: 'conversation';
+    conversation: HouseListedConversation;
+} | {
+    type: 'conversation_deleted';
+    conversation_id: string;
 } | {
     type: 'signal';
     service_mode: string;
+}>;
+export type HouseHeldRoom = {
+    authority: string;
+    position: string;
+    log_epoch: string;
+};
+export type HouseOpening = {
+    hold(rooms: readonly HouseHeldRoom[], runtime: string): void;
+    received(authority: string, carry: string, index: number): void;
+    close(): void;
+};
+export type HouseClosing = {
+    revoked: boolean;
+    lost: boolean;
 };
 export type HouseStream = {
     observe(receive: (frame: HouseStreamFrame) => void): () => void;
-    opened(notify: () => void): () => void;
+    opened(notify: (opening: HouseOpening) => void): () => void;
+    closed(notify: (closing: HouseClosing) => void): () => void;
+};
+export type HouseStreamed = HouseDoorAnswer & {
+    room: ReadableStream<Uint8Array> | null;
 };
 export type HouseDoor = {
     door(route: string, body: unknown): Promise<HouseDoorAnswer>;
     stream: HouseStream;
 };
 export type HouseTransport = HouseDoor & {
+    streamed(route: string, body: unknown, signal: AbortSignal): Promise<HouseStreamed>;
     transfer(request: HouseByteTransfer): Promise<HouseDoorAnswer>;
+    put(url: string, body: Blob, headers: Readonly<Record<string, string>>): Promise<number>;
+    download(url: string): Promise<HouseBytesAnswer>;
 };
 export type HouseSiteTransport = HouseDoor & {
     online(): boolean;
     read(route: string): Promise<HouseDoorAnswer>;
+    streamed(route: string, signal: AbortSignal): Promise<HouseStreamed>;
+    download(route: string): Promise<HouseBytesAnswer>;
 };
 export {};
 //# sourceMappingURL=transport.d.ts.map