@agentshouse/mdruntime-adapter 0.1.0-alpha.8 → 0.1.0-c6ddfd288ac81

package/dist/site.js

@@ -1,40 +1,28 @@
-import { mapDiscovery, parseSiteDiscovery, siteCapabilities, siteTracked } from './discovery.js';
-import { MODEL_ABSENT, failedModel, heldModel, modelKey, modelShelf } from './model.js';
-import { advancedScope, authorityRoot, bootstrapOf, definitionsOf, parseEnumeration, parseSiteBootstrap, refreshFrom, selectionRoots } from './read.js';
-import { classifyDoor, discoveryFailure } from './refusal.js';
+import { actionOutcome } from './actions.js';
+import { UNTYPED_FOLDERS, mapDiscovery, parseSiteDiscovery, siteCapabilities, siteSlots, siteTracked, } from './discovery.js';
+import { MODEL_ABSENT, failedModel, heldModel, modelKey, modelShelf, } from './model.js';
+import { advancedScope, bootstrapOf, parseEnumeration, parseSiteBootstrap, refreshFrom, schemaOf, schemaPath, viewOf, } from './read.js';
+import { classifyDoor, discoveryFailure, doorRefusal } from './refusal.js';
 import { houseNotifications } from './stream.js';
-import { PRIVATE_AUTHORITY, SITE_DOOR_BOOTSTRAP, SITE_DOOR_DISCOVER, SITE_DOOR_ENUMERATE } from './transport.js';
-import { logPosition, presented, roomVersion } from './version.js';
-const UNCERTAIN = {
-    kind: 'transport-uncertainty'
-};
+import { PRIVATE_LOCATOR, SITE_DOOR_BOOTSTRAP, SITE_DOOR_DISCOVER, SITE_DOOR_ENUMERATE, SITE_DOOR_SUBMIT, } from './transport.js';
+import { logPosition, presented, reachedVersion, roomVersion, } from './version.js';
+const UNCERTAIN = { kind: 'transport-uncertainty' };
 function siteRoom(tracked, attachedModel) {
-    const read = selectionRoots(tracked);
     return {
-        name: tracked.slot,
+        name: tracked.handle,
         locator: tracked.locator,
-        collectionRoot: tracked.collectionRoot,
         roomVersion: roomVersion(tracked),
-        operations: {
-            read: [
-                ...read
-            ],
-            sync: [
-                ...read
-            ],
-            write: [],
-            delete: []
-        },
-        replica: {
-            selection: tracked.locator,
-            admission: 'admitted'
-        },
+        operations: { read: [''], sync: [''], write: [], delete: [] },
+        replica: { selection: tracked.locator, admission: 'admitted' },
         attachedModel,
-        providerOwnedPaths: []
+        untypedFolders: [...UNTYPED_FOLDERS],
+        providerOwnedPaths: [],
     };
 }
 function settled(refused) {
-    return refused.kind === 'beyond-horizon' ? UNCERTAIN : refused;
+    return refused.kind === 'beyond-horizon' || refused.kind === 'retryable-refusal'
+        ? UNCERTAIN
+        : refused;
 }
 export function createSiteAdapter(transport) {
     const notifications = houseNotifications(transport, 'site');
@@ -44,92 +32,84 @@ export function createSiteAdapter(transport) {
     let caught = new Map();
     async function enumeration(entry, from) {
         const answer = await transport.door(SITE_DOOR_ENUMERATE, {
-            positions: [
-                presented(entry.authority, from)
-            ]
+            positions: [presented(entry.authority, from)],
         });
+        const behind = doorRefusal(answer.body);
+        if (behind?.code === 'replica_behind')
+            return { kind: 'retryable-refusal', ...behind };
         const classified = classifyDoor(answer.status, answer.body, entry.locator);
-        if (classified !== null) return classified;
+        if (classified !== null)
+            return classified;
         return parseEnumeration(answer.body, 'site') ?? UNCERTAIN;
     }
     async function caughtUp(entry) {
         const answer = await transport.read(`${SITE_DOOR_BOOTSTRAP}${entry.authority}`);
         const classified = classifyDoor(answer.status, answer.body, entry.locator);
-        if (classified !== null) return {
-            failure: settled(classified)
-        };
+        if (classified !== null)
+            return { failure: settled(classified) };
         const scope = parseSiteBootstrap(answer.body);
-        if (scope === null) return {
-            failure: UNCERTAIN
-        };
-        if (roomVersion(scope) === roomVersion(entry)) return {
-            scope
-        };
+        if (scope === null)
+            return { failure: UNCERTAIN };
+        if (roomVersion(scope) === roomVersion(entry))
+            return { scope };
         const found = await enumeration(entry, scope);
-        if ('kind' in found) return {
-            failure: settled(found)
-        };
-        const view = found.authorities.find((held)=>held.authority === entry.authority);
-        if (view === undefined) return {
-            failure: {
-                kind: 'room-not-readable',
-                locator: entry.locator
-            }
-        };
-        return {
-            scope: advancedScope(scope, view)
-        };
+        if ('kind' in found)
+            return { failure: settled(found) };
+        const view = viewOf(found, entry);
+        if (view === undefined)
+            return { failure: { kind: 'room-not-readable', locator: entry.locator } };
+        return { scope: advancedScope(scope, view) };
     }
     async function refreshed(entry, fromRoomVersion) {
         const from = logPosition(fromRoomVersion);
-        if (from === null) return {
-            kind: 'beyond-horizon'
-        };
+        if (from === null)
+            return { kind: 'beyond-horizon' };
         const streamed = notifications.advance(entry, from);
-        if (streamed !== null) return streamed;
+        if (streamed !== null)
+            return streamed.page;
         const found = await enumeration(entry, from);
-        if ('kind' in found) return found;
-        return refreshFrom(found, entry, fromRoomVersion);
+        if ('kind' in found)
+            return found;
+        const view = viewOf(found, entry);
+        if (view === undefined)
+            return { kind: 'room-not-readable', locator: entry.locator };
+        return refreshFrom(view, entry, fromRoomVersion);
     }
     async function acquire(entry, held) {
-        if ('failure' in held) return {
-            snapshot: failedModel(held.failure),
-            identity: null
-        };
-        const model = await heldModel(definitionsOf(held.scope, entry.modelRoot), `${authorityRoot(entry.handle)}/${entry.modelRoot}`, MODEL_ABSENT);
-        acquired.set(entry.authority, {
-            roomVersion: roomVersion(held.scope),
-            model
-        });
+        if ('failure' in held)
+            return { snapshot: failedModel(held.failure), identity: null };
+        const model = await heldModel(schemaOf(held.scope, entry.schema), schemaPath(entry.handle, entry.schema), MODEL_ABSENT);
+        acquired.set(entry.authority, { roomVersion: roomVersion(held.scope), model });
         return model;
     }
     return {
-        async authorize () {
+        async authorize() {
             return {};
         },
-        async model (_authorization, request) {
+        async model(_authorization, request) {
             return models.answer(request);
         },
-        async discover () {
-            const answer = await transport.door(SITE_DOOR_DISCOVER, {});
-            const classified = classifyDoor(answer.status, answer.body, PRIVATE_AUTHORITY);
-            if (classified !== null) return discoveryFailure(classified);
+        async discover() {
+            const answer = await transport.read(SITE_DOOR_DISCOVER);
+            const classified = classifyDoor(answer.status, answer.body, PRIVATE_LOCATOR);
+            if (classified !== null)
+                return discoveryFailure(classified);
             const document = parseSiteDiscovery(answer.body);
-            if (document === null) return UNCERTAIN;
+            if (document === null)
+                return UNCERTAIN;
             const entries = siteTracked(document);
             tracked.clear();
-            for (const entry of entries)tracked.set(entry.locator, entry);
+            for (const entry of entries)
+                tracked.set(entry.locator, entry);
             notifications.track(entries);
-            const published = new Set(entries.map((entry)=>entry.authority));
-            for (const authority of [
-                ...acquired.keys()
-            ]){
-                if (!published.has(authority)) acquired.delete(authority);
+            const published = new Set(entries.map((entry) => entry.authority));
+            for (const authority of [...acquired.keys()]) {
+                if (!published.has(authority))
+                    acquired.delete(authority);
             }
             const fresh = new Map();
             const current = new Map();
-            for (const entry of entries){
-                if (current.has(entry.authority)) continue;
+            for (const entry of entries) {
                 const kept = acquired.get(entry.authority);
                 if (kept !== undefined && kept.roomVersion === roomVersion(entry)) {
                     current.set(entry.authority, kept.model);
@@ -140,59 +120,63 @@ export function createSiteAdapter(transport) {
                 current.set(entry.authority, await acquire(entry, held));
             }
             caught = fresh;
-            const rooms = entries.map((entry)=>{
+            const rooms = entries.map((entry) => {
                 const shelved = models.retain(modelKey(entry.locator, 'collection'), current.get(entry.authority));
                 return siteRoom(entry, shelved?.identity ?? null);
             });
-            models.keep(entries.map((entry)=>entry.locator));
-            return mapDiscovery(document, rooms, siteCapabilities());
+            models.keep(entries.map((entry) => entry.locator));
+            return { ...mapDiscovery(document, rooms, siteCapabilities()), slots: siteSlots(document) };
         },
-        async bootstrap (_authorization, request) {
+        async bootstrap(_authorization, request) {
             const entry = tracked.get(request.locator);
-            if (entry === undefined) return {
-                kind: 'room-not-readable',
-                locator: request.locator
-            };
-            if (request.pageToken !== undefined) return UNCERTAIN;
-            const held = caught.get(entry.authority) ?? await caughtUp(entry);
-            if ('failure' in held) return held.failure;
+            if (entry === undefined)
+                return { kind: 'room-not-readable', locator: request.locator };
+            if (request.pageToken !== undefined)
+                return UNCERTAIN;
+            const held = caught.get(entry.authority) ?? (await caughtUp(entry));
+            if ('failure' in held)
+                return held.failure;
             return bootstrapOf(held.scope, entry);
         },
-        async refresh (_authorization, request) {
+        async refresh(_authorization, request) {
             const entry = tracked.get(request.locator);
-            if (entry === undefined) return {
-                kind: 'room-not-readable',
-                locator: request.locator
-            };
-            if (request.pageToken !== undefined) return UNCERTAIN;
+            if (entry === undefined)
+                return { kind: 'room-not-readable', locator: request.locator };
+            if (request.pageToken !== undefined)
+                return UNCERTAIN;
             const result = await refreshed(entry, request.fromRoomVersion);
-            if (result.kind === 'beyond-horizon') caught.delete(entry.authority);
+            if (result.kind === 'beyond-horizon')
+                caught.delete(entry.authority);
+            const answered = result.kind === 'net-advancement'
+                ? result.roomVersion
+                : result.kind === 'still-current'
+                    ? request.fromRoomVersion
+                    : null;
+            if (request.minPosition !== undefined &&
+                answered !== null &&
+                !reachedVersion(answered, request.minPosition, entry.logEpoch)) {
+                return { kind: 'retryable-refusal', code: 'replica_behind', fields: {} };
+            }
             return result;
         },
-        async mutate () {
-            return {
-                kind: 'rejected',
-                affected: {},
-                code: 'write-grant',
-                fields: {}
-            };
+        async mutate() {
+            return { kind: 'rejected', affected: {}, code: 'write-grant', fields: {} };
         },
-        async history () {
-            return {
-                kind: 'no-history'
-            };
+        async history() {
+            return { kind: 'no-history' };
         },
-        async action (_authorization, request) {
-            return {
-                kind: 'rejected',
-                code: 'action-unimplemented',
-                fields: {
-                    name: request.name
-                }
-            };
+        reached(locator, version, target) {
+            return reachedVersion(version, target, tracked.get(locator)?.logEpoch);
+        },
+        async action(_authorization, request) {
+            if (request.name !== 'submit') {
+                return { kind: 'rejected', code: 'action-unimplemented', fields: { name: request.name } };
+            }
+            if (!transport.online())
+                return UNCERTAIN;
+            return actionOutcome(await transport.door(SITE_DOOR_SUBMIT, request.input), 'submit');
         },
-        roomVersions: notifications
+        roomVersions: notifications,
+        serviceMode: notifications.serviceMode,
     };
 }
-
-//# sourceMappingURL=site.js.map

package/dist/stream.d.ts

@@ -1,12 +1,16 @@
-import type { RefreshPage, SelectedRooms, ViewedConversations } from '@agentshouse/mdruntime';
+import type { ConversationStream, RefreshPage, SelectedRooms, ServiceModeSignal } from '@agentshouse/mdruntime';
 import type { TrackedAuthority } from './discovery.js';
-import { type HouseDoor } from './transport.js';
-import type { HouseMode } from './transport.js';
+import type { HouseDoor, HouseMode, HouseStreamEntry } from './transport.js';
 import { type LogPosition } from './version.js';
+export type StreamedAdvancement = {
+    page: RefreshPage;
+    entries: readonly HouseStreamEntry[];
+};
 export type HouseNotifications = SelectedRooms & {
     track(authorities: readonly TrackedAuthority[]): void;
-    advance(tracked: TrackedAuthority, from: LogPosition): RefreshPage | null;
-    conversations: ViewedConversations;
+    advance(tracked: TrackedAuthority, from: LogPosition): StreamedAdvancement | null;
+    conversations: ConversationStream;
+    serviceMode: ServiceModeSignal;
 };
 export declare function houseNotifications(transport: HouseDoor, mode: HouseMode): HouseNotifications;
 //# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,WAAW,EAEX,aAAa,EACb,mBAAmB,EACpB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAqB,KAAK,SAAS,EAA6B,MAAM,gBAAgB,CAAC;AAC9F,OAAO,KAAK,EAAE,SAAS,EAAsC,MAAM,gBAAgB,CAAC;AACpF,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAc7D,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,KAAK,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,CAAC;IACtD,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAAC;IAC1E,aAAa,EAAE,mBAAmB,CAAC;CACpC,CAAC;AAaF,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,kBAAkB,CA+O5F"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAClB,WAAW,EAEX,aAAa,EAEb,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAoB,MAAM,gBAAgB,CAAC;AAC/F,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAc7D,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAC/C,KAAK,CAAC,WAAW,EAAE,SAAS,gBAAgB,EAAE,GAAG,IAAI,CAAC;IACtD,OAAO,CAAC,OAAO,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,mBAAmB,GAAG,IAAI,CAAC;IAClF,aAAa,EAAE,kBAAkB,CAAC;IAClC,WAAW,EAAE,iBAAiB,CAAC;CAChC,CAAC;AAOF,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,GAAG,kBAAkB,CAsQ5F"}