@agentshouse/mdruntime-adapter 0.1.0-ca218e62303fd → 0.1.0-ca231c2cbedb4

package/dist/read.js

@@ -1,13 +1,72 @@
+import { paced, patching, ROW_WEIGHT, stepped, } from '@agentshouse/mdruntime';
+import { checkedPayload, gunzipped, parsePart } from './part.js';
 import { DECIMAL, readPosition, roomVersion } from './version.js';
+const REVISION_FILE = /^fr_([0-9a-z]+)\.[0-9a-z]+\.[0-9a-z]$/u;
+function fileOf(revision) {
+    return REVISION_FILE.exec(revision)?.[1];
+}
+export function answering() {
+    return {
+        documents: new Map(),
+        revisions: new Map(),
+        fileIds: new Map(),
+        changes: new Map(),
+        binaryFiles: new Map(),
+        removals: new Set(),
+        folders: new Set(),
+        folderRemovals: new Set(),
+    };
+}
+export function revised(answer, path, revision) {
+    answer.revisions.set(path, revision);
+    const file = fileOf(revision);
+    if (file !== undefined)
+        answer.fileIds.set(path, file);
+}
+export function forgotten(answer, path) {
+    answer.documents.delete(path);
+    answer.revisions.delete(path);
+    answer.fileIds.delete(path);
+    answer.changes.delete(path);
+    answer.binaryFiles.delete(path);
+    answer.removals.delete(path);
+}
+export function folded(answer, path, removed) {
+    if (removed) {
+        answer.folders.delete(path);
+        answer.folderRemovals.add(path);
+    }
+    else {
+        answer.folderRemovals.delete(path);
+        answer.folders.add(path);
+    }
+}
+function* pathsOf(paths) {
+    const list = [];
+    for (const path of paths) {
+        list.push(path);
+        yield ROW_WEIGHT;
+    }
+    return list;
+}
+export function* answered(answer) {
+    const removals = yield* pathsOf(answer.removals);
+    return {
+        documents: yield* patching({}, answer.documents),
+        revisions: yield* patching({}, answer.revisions),
+        ...(answer.fileIds.size === 0 ? {} : { fileIds: yield* patching({}, answer.fileIds) }),
+        changes: yield* patching({}, answer.changes),
+        binaryFiles: yield* patching({}, answer.binaryFiles),
+        removals,
+        ...(answer.folders.size === 0 ? {} : { folders: yield* pathsOf(answer.folders) }),
+        ...(answer.folderRemovals.size === 0
+            ? {}
+            : { folderRemovals: yield* pathsOf(answer.folderRemovals) }),
+    };
+}
 export function authorityRoot(handle) {
     return `/rooms/${handle}`;
 }
-export function contentPrefixes(tracked) {
-    return [
-        authorityRoot(tracked.handle),
-        ...tracked.schemas.map((schema) => schemaPath(tracked.handle, schema)),
-    ];
-}
 export function schemaPath(handle, schema) {
     return `${authorityRoot(handle)}/${schema}`;
 }
@@ -20,22 +79,37 @@ export function parseGrant(body) {
     const transfer = body.transfer;
     if (typeof transfer.url !== 'string')
         return null;
-    if (transfer.method === 'GET')
-        return { method: 'GET', url: transfer.url };
     if (transfer.method !== 'POST' || typeof transfer.operation !== 'string')
         return null;
-    return { method: 'POST', operation: transfer.operation, url: transfer.url };
+    return { operation: transfer.operation, url: transfer.url };
+}
+export function parseFileAddress(body) {
+    if (typeof body !== 'object' || body === null)
+        return null;
+    const { download, name, sha256, media_type: mediaType } = body;
+    if (typeof download !== 'string' ||
+        typeof name !== 'string' ||
+        typeof sha256 !== 'string' ||
+        typeof mediaType !== 'string') {
+        return null;
+    }
+    return { url: download, name, sha256, mediaType };
 }
 function changeAuthor(value) {
     if (typeof value !== 'object' || value === null)
         return null;
-    const { user, site, name } = value;
+    const { user, site, inbox, name } = value;
     if (typeof name !== 'string')
         return null;
-    if (typeof user === 'string' && site === undefined)
+    const named = [user, site, inbox].filter((id) => id !== undefined);
+    if (named.length !== 1)
+        return null;
+    if (typeof user === 'string')
         return { kind: 'user', id: user, name };
-    if (typeof site === 'string' && user === undefined)
+    if (typeof site === 'string')
         return { kind: 'site', id: site, name };
+    if (typeof inbox === 'string')
+        return { kind: 'inbox', id: inbox, name };
     return null;
 }
 export function headChange(held) {
@@ -52,15 +126,12 @@ function headed(head) {
     return head === undefined ? {} : { head };
 }
 export function binaryFileOf(held) {
-    if (held.file === undefined)
+    if (held.media_type === undefined)
         return undefined;
-    const { file, bytes, media_type: mediaType, sha256 } = held;
-    if (typeof file !== 'string' ||
-        typeof bytes !== 'number' ||
-        typeof mediaType !== 'string' ||
-        typeof sha256 !== 'string')
+    const { bytes, media_type: mediaType, sha256 } = held;
+    if (typeof bytes !== 'number' || typeof mediaType !== 'string' || typeof sha256 !== 'string')
         return null;
-    return { fileRef: file, byteLength: bytes, mediaType, sha256 };
+    return { byteLength: bytes, mediaType, sha256 };
 }
 function binaried(binary) {
     return binary === undefined ? {} : { binary };
@@ -97,13 +168,31 @@ function parseFile(value, mode) {
         ...binaried(binary),
     };
 }
-function parseScope(value, mode) {
+function parseModels(value, mode) {
+    if (!Array.isArray(value))
+        return null;
+    const files = [];
+    const contents = [];
+    for (const entry of value) {
+        const file = parseFile(entry, mode);
+        const { content } = entry;
+        if (file === null || typeof content !== 'string')
+            return null;
+        files.push(file);
+        contents.push({ path: file.path, content });
+    }
+    return { files, contents };
+}
+function parseRoomParts(value, mode) {
     if (typeof value !== 'object' || value === null)
         return null;
     const held = value;
     if (typeof held.manifest !== 'object' || held.manifest === null)
         return null;
-    if (!Array.isArray(held.contents))
+    if (!Array.isArray(held.parts))
+        return null;
+    const models = parseModels(held.models, mode);
+    if (models === null)
         return null;
     const manifest = held.manifest;
     if (manifest.scope !== 'room')
@@ -113,77 +202,136 @@ function parseScope(value, mode) {
         return null;
     if (typeof manifest.room_handle !== 'string' || manifest.room_handle.length === 0)
         return null;
-    if (!Array.isArray(manifest.files))
-        return null;
-    const files = [];
-    for (const entry of manifest.files) {
-        const file = parseFile(entry, mode);
-        if (file === null)
+    const parts = [];
+    for (const entry of held.parts) {
+        const part = parsePart(entry);
+        if (part === null)
             return null;
-        files.push(file);
+        parts.push(part);
     }
-    const contents = [];
-    for (const entry of held.contents) {
-        if (typeof entry !== 'object' || entry === null)
-            return null;
-        const content = entry;
-        if (typeof content.path !== 'string' || typeof content.content !== 'string')
-            return null;
-        contents.push({ path: content.path, content: content.content });
-    }
-    return { anchor: manifest.anchor, ...at, files, contents };
-}
-function parseCut(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== 'object' || value === null)
-        return null;
-    const { position, log_epoch: logEpoch } = value;
-    if (typeof position !== 'string' || typeof logEpoch !== 'string')
-        return null;
-    return { position, log_epoch: logEpoch };
-}
-function parseCursor(value) {
-    if (typeof value !== 'object' || value === null)
-        return null;
-    const { room, path, cut } = value;
-    if (typeof room !== 'string' || (path !== null && typeof path !== 'string'))
-        return null;
-    const parsed = parseCut(cut);
-    if (parsed === null)
-        return null;
-    return { room, path, ...(parsed === undefined ? {} : { cut: parsed }) };
+    return { anchor: manifest.anchor, ...at, models, parts };
 }
-export function parseEnvelope(body) {
+export function parseParted(body) {
     if (typeof body !== 'object' || body === null)
         return null;
     if (!('scopes' in body) || !Array.isArray(body.scopes))
         return null;
-    const scopes = [];
+    const rooms = [];
     for (const entry of body.scopes) {
-        const scope = parseScope(entry, 'credential');
-        if (scope === null)
+        const room = parseRoomParts(entry, 'credential');
+        if (room === null)
             return null;
-        scopes.push(scope);
+        rooms.push(room);
     }
     if (!('next' in body) || body.next === undefined)
-        return { scopes };
-    const next = parseCursor(body.next);
-    return next === null ? null : { scopes, next };
+        return { rooms };
+    const next = body.next;
+    if (typeof next !== 'object' || next === null || typeof next.room !== 'string')
+        return null;
+    return { rooms, next: next.room };
+}
+export function parseSiteParted(body) {
+    return parseRoomParts(body, 'site');
+}
+export function partInventory(room) {
+    return {
+        parts: room.parts.length,
+        bytes: room.parts.reduce((sum, part) => sum + part.bytes, 0),
+    };
+}
+export function manifested(room, inventory, pageToken, models) {
+    return {
+        kind: 'bootstrap',
+        roomVersion: roomVersion(room),
+        documents: {},
+        revisions: {},
+        changes: {},
+        binaryFiles: {},
+        inventory,
+        pageToken,
+        ...(models === undefined ? {} : { models }),
+    };
+}
+export function modelScope(room) {
+    return { ...emptyScope(room), files: room.models.files, contents: room.models.contents };
+}
+export function emptyScope(room) {
+    return {
+        anchor: room.anchor,
+        position: room.position,
+        logEpoch: room.logEpoch,
+        files: [],
+        contents: [],
+    };
+}
+function partLine(line, mode, read) {
+    let entry;
+    try {
+        entry = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    if (folderLine(entry)) {
+        read.folders.push(entry.folder);
+        return true;
+    }
+    const file = parseFile(entry, mode);
+    if (file === null)
+        return false;
+    read.files.push(file);
+    const { content } = entry;
+    if (typeof content === 'string')
+        read.contents.push({ path: file.path, content });
+    else if (content !== undefined)
+        return false;
+    return true;
+}
+async function partRead(chunks, mode) {
+    const read = { files: [], contents: [], folders: [] };
+    const pace = paced();
+    const unfinished = [];
+    for (let chunk = await chunks.read(); chunk.done !== true; chunk = await chunks.read()) {
+        const text = chunk.value;
+        let start = 0;
+        for (let end = text.indexOf('\n'); end !== -1; end = text.indexOf('\n', start)) {
+            const piece = text.slice(start, end);
+            const line = unfinished.length === 0 ? piece : unfinished.splice(0).join('') + piece;
+            if (!partLine(line, mode, read)) {
+                await chunks.cancel();
+                return null;
+            }
+            start = end + 1;
+            const due = pace(line.length + ROW_WEIGHT);
+            if (due instanceof Promise)
+                await due;
+        }
+        if (start < text.length)
+            unfinished.push(text.slice(start));
+    }
+    return unfinished.length === 0 ? read : null;
 }
-export function parseSiteBootstrap(body) {
-    return parseScope(body, 'site');
+function folderLine(entry) {
+    if (typeof entry !== 'object' || entry === null || !('folder' in entry))
+        return false;
+    return typeof entry.folder === 'string' && Object.keys(entry).length === 1;
 }
-export function siteBootstrapNext(body) {
-    if (typeof body !== 'object' || body === null || !('next' in body))
+export async function housePart(room, frame, listed, mode) {
+    const payload = await checkedPayload(frame, listed);
+    if (payload === null)
         return null;
-    return typeof body.next === 'string' && body.next.length > 0 ? body.next : null;
+    const read = await partRead(gunzipped(payload).getReader(), mode).catch(() => null);
+    return read === null ? { kind: 'transport-uncertainty' } : { ...emptyScope(room), ...read };
 }
-export function siteBootstrapOffset(body) {
-    if (typeof body !== 'object' || body === null || !('offset' in body))
+function folderChange(value) {
+    if (typeof value !== 'object' || value === null)
         return null;
-    return Number.isSafeInteger(body.offset) && body.offset > 0
-        ? body.offset
+    const { path, folder, removed, ...rest } = value;
+    return typeof path === 'string' &&
+        folder === true &&
+        (removed === undefined || removed === true) &&
+        Object.keys(rest).length === 0
+        ? { path, removed: removed === true }
         : null;
 }
 function parseChange(value, mode) {
@@ -242,7 +390,13 @@ export function parseEnumeration(body, mode) {
         if (!Array.isArray(held.changes))
             return null;
         const changes = [];
+        const folders = [];
         for (const change of held.changes) {
+            const folder = folderChange(change);
+            if (folder !== null) {
+                folders.push(folder);
+                continue;
+            }
             const mapped = parseChange(change, mode);
             if (mapped === null)
                 return null;
@@ -255,6 +409,7 @@ export function parseEnumeration(body, mode) {
             authority: held.authority,
             ...at,
             changes,
+            ...(folders.length === 0 ? {} : { folders }),
             ...(next === undefined ? {} : { next }),
         });
     }
@@ -278,6 +433,7 @@ function advances(asked, next) {
 }
 export async function wholeView(first, more) {
     const changes = new Map(first.changes.map((change) => [change.path, change]));
+    const folders = new Map((first.folders ?? []).map((folder) => [folder.path, folder]));
     let view = first;
     while (view.next !== undefined) {
         const asked = view.next;
@@ -293,6 +449,10 @@ export async function wholeView(first, more) {
             changes.delete(change.path);
             changes.set(change.path, change);
         }
+        for (const folder of page.folders ?? []) {
+            folders.delete(folder.path);
+            folders.set(folder.path, folder);
+        }
         view = page;
     }
     return {
@@ -300,62 +460,32 @@ export async function wholeView(first, more) {
         position: view.position,
         logEpoch: first.logEpoch,
         changes: [...changes.values()],
+        ...(folders.size === 0 ? {} : { folders: [...folders.values()] }),
     };
 }
-export function advancedScope(scope, view) {
-    const files = new Map(scope.files.map((file) => [file.path, file]));
-    const contents = new Map(scope.contents.map((entry) => [entry.path, entry.content]));
-    for (const change of view.changes) {
-        files.delete(change.path);
-        contents.delete(change.path);
-        if ('removed' in change)
-            continue;
-        files.set(change.path, {
-            path: change.path,
-            revision: change.revision,
-            version: change.version,
-            ...headed(change.head),
-            ...('binary' in change ? { binary: change.binary } : {}),
-        });
-        if ('content' in change)
-            contents.set(change.path, change.content);
+export function* bootstrapping(scope) {
+    const contents = new Map();
+    for (const entry of scope.contents) {
+        contents.set(entry.path, entry.content);
+        yield ROW_WEIGHT;
     }
-    return {
-        ...scope,
-        position: view.position,
-        logEpoch: view.logEpoch,
-        files: [...files.values()],
-        contents: [...contents].map(([path, content]) => ({ path, content })),
-    };
-}
-export function matchesScope(scope, tracked) {
-    return scope.anchor === tracked.authority;
-}
-export function bootstrapOf(scope) {
-    const contents = new Map(scope.contents.map((entry) => [entry.path, entry.content]));
-    const documents = {};
-    const revisions = {};
-    const changes = {};
-    const binaryFiles = {};
+    const answer = answering();
     for (const file of scope.files) {
-        if (file.revision !== undefined)
-            revisions[file.path] = file.revision;
+        yield ROW_WEIGHT;
         if (file.head !== undefined)
-            changes[file.path] = file.head;
+            answer.changes.set(file.path, file.head);
         const content = contents.get(file.path);
         if (file.binary !== undefined)
-            binaryFiles[file.path] = file.binary;
+            answer.binaryFiles.set(file.path, file.binary);
         else if (content !== undefined)
-            documents[file.path] = content;
+            answer.documents.set(file.path, content);
+        if (file.revision !== undefined)
+            revised(answer, file.path, file.revision);
     }
-    return {
-        kind: 'bootstrap',
-        roomVersion: roomVersion(scope),
-        documents,
-        revisions,
-        changes,
-        binaryFiles,
-    };
+    for (const folder of scope.folders ?? [])
+        folded(answer, folder, false);
+    const { removals: _removals, folderRemovals: _folderRemovals, ...page } = yield* answered(answer);
+    return { kind: 'bootstrap', roomVersion: roomVersion(scope), ...page };
 }
 export function schemaOf(scope, schema) {
     const file = scope.files.find((entry) => entry.path === schema);
@@ -369,35 +499,31 @@ export function schemaOf(scope, schema) {
 export function viewOf(enumeration, tracked) {
     return enumeration.authorities.find((entry) => entry.authority === tracked.authority);
 }
-export function refreshFrom(view, fromRoomVersion) {
+function* refreshing(view, fromRoomVersion) {
     if (roomVersion(view) === fromRoomVersion)
         return { kind: 'still-current' };
-    const documents = {};
-    const revisions = {};
-    const changes = {};
-    const binaryFiles = {};
-    const removals = [];
+    const answer = answering();
     for (const change of view.changes) {
+        yield ROW_WEIGHT;
         if ('removed' in change) {
-            removals.push(change.path);
+            answer.removals.add(change.path);
             continue;
         }
         if ('content' in change)
-            documents[change.path] = change.content;
+            answer.documents.set(change.path, change.content);
         else
-            binaryFiles[change.path] = change.binary;
-        if (change.revision !== undefined)
-            revisions[change.path] = change.revision;
+            answer.binaryFiles.set(change.path, change.binary);
         if (change.head !== undefined)
-            changes[change.path] = change.head;
+            answer.changes.set(change.path, change.head);
+        if (change.revision !== undefined)
+            revised(answer, change.path, change.revision);
     }
-    return {
-        kind: 'net-advancement',
-        roomVersion: roomVersion(view),
-        documents,
-        revisions,
-        changes,
-        binaryFiles,
-        removals: removals.sort(),
-    };
+    for (const folder of view.folders ?? []) {
+        yield ROW_WEIGHT;
+        folded(answer, folder.path, folder.removed);
+    }
+    return { kind: 'net-advancement', roomVersion: roomVersion(view), ...(yield* answered(answer)) };
+}
+export async function refreshFrom(view, fromRoomVersion) {
+    return stepped(refreshing(view, fromRoomVersion));
 }

package/dist/room-types.d.ts

@@ -0,0 +1,7 @@
+export declare const INBOX_CHANNEL_KINDS: readonly ['telegram-bot', 'whatsapp', 'messenger', 'instagram', 'viber', 'tiktok'];
+export type InboxChannelKind = (typeof INBOX_CHANNEL_KINDS)[number];
+export declare const INBOX_CHAT_TYPE = "inbox-chat";
+export declare const INBOX_MESSAGE_TYPE = "inbox-message";
+export declare const HOUSE_NAMEABLE_ROOM_TYPES: string[];
+export declare const HOUSE_ROOM_TYPES: string;
+//# sourceMappingURL=room-types.d.ts.map

package/dist/room-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-types.d.ts","sourceRoot":"","sources":["../src/room-types.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,mBAAmB,YAC9B,cAAc,EACd,UAAU,EACV,WAAW,EACX,WAAW,EACX,OAAO,EACP,QAAQ,CACA,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,eAAO,MAAM,eAAe,eAAe,CAAC;AAE5C,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD,eAAO,MAAM,yBAAyB,UAAwC,CAAC;AAyB/E,eAAO,MAAM,gBAAgB,QA6FjB,CAAC"}

package/dist/room-types.js

@@ -0,0 +1,124 @@
+import { APP_REFERENCE_PATTERN } from './app-reference.js';
+import { HOUSE_MODEL_TYPES } from './house-model.js';
+export const INBOX_CHANNEL_KINDS = [
+    'telegram-bot',
+    'whatsapp',
+    'messenger',
+    'instagram',
+    'viber',
+    'tiktok',
+];
+export const INBOX_CHAT_TYPE = 'inbox-chat';
+export const INBOX_MESSAGE_TYPE = 'inbox-message';
+export const HOUSE_NAMEABLE_ROOM_TYPES = [INBOX_CHAT_TYPE, INBOX_MESSAGE_TYPE];
+const WAYFINDING_MAP_TYPE = 'wayfinding-map';
+const WAYFINDING_TICKET_TYPE = 'wayfinding-ticket';
+const WAYFINDING_MAP_SECTIONS = [
+    'Destination',
+    'Notes',
+    'Decisions so far',
+    'Not yet specified',
+    'Out of scope',
+];
+const IDENTITY = "{ type: string, pattern: '^\\S+$' }";
+const AGENT = ['        agent: { type: string, format: uuid }', '        name: { type: string }'];
+const ASSIGNEE = [
+    '      type: object',
+    '      properties:',
+    '        user: { type: string, format: uuid }',
+    ...AGENT,
+];
+export const HOUSE_ROOM_TYPES = [
+    `${INBOX_CHAT_TYPE}:`,
+    '  properties:',
+    '    inbox: { type: string, format: uuid }',
+    `    channel: { enum: [${INBOX_CHANNEL_KINDS.join(', ')}] }`,
+    `    chat: ${IDENTITY}`,
+    '    customer:',
+    '      type: object',
+    '      properties:',
+    '        name: { type: string }',
+    `        username: ${IDENTITY}`,
+    `        phone: ${IDENTITY}`,
+    '    assignee:',
+    ...ASSIGNEE,
+    '    return_to:',
+    '      type: object',
+    '      properties:',
+    ...AGENT,
+    '    conversation: { type: string, format: uuid }',
+    '  required: [inbox, channel, chat, customer]',
+    `${INBOX_MESSAGE_TYPE}:`,
+    '  properties:',
+    '    direction: { enum: [in, out] }',
+    '    sender:',
+    '      type: object',
+    '      properties:',
+    '        name: { type: string }',
+    `        username: ${IDENTITY}`,
+    '    sent_at: { type: string, format: date-time }',
+    `    channel_message: ${IDENTITY}`,
+    '    state: { enum: [sending, sent, failed] }',
+    '    reason: { type: string }',
+    '    reactions:',
+    '      type: array',
+    '      items:',
+    '        type: object',
+    '        properties:',
+    '          reaction: { type: string, minLength: 1 }',
+    '          sender:',
+    '            type: object',
+    '            properties:',
+    `              id: ${IDENTITY}`,
+    '              name: { type: string }',
+    `              username: ${IDENTITY}`,
+    '          count: { type: integer, minimum: 1 }',
+    '        required: [reaction]',
+    `    post: ${IDENTITY}`,
+    '    assignee:',
+    ...ASSIGNEE,
+    '    sent_outside: { const: true }',
+    '    template:',
+    '      type: object',
+    '      properties:',
+    '        name: { type: string, minLength: 1 }',
+    '        language: { type: string, minLength: 1 }',
+    '      required: [name, language]',
+    '    values:',
+    '      type: object',
+    '      additionalProperties: { type: string }',
+    '    withheld: { const: true }',
+    '  required: [direction]',
+    '  if: { properties: { direction: { const: in } } }',
+    '  then: { required: [sent_at] }',
+    `${WAYFINDING_MAP_TYPE}:`,
+    '  properties:',
+    '    title: { type: string }',
+    '  required: [title]',
+    '  sections:',
+    ...WAYFINDING_MAP_SECTIONS.map((name) => `    ${name}: { kind: text, required: true }`),
+    `${WAYFINDING_TICKET_TYPE}:`,
+    '  properties:',
+    '    title: { type: string }',
+    '    kind: { enum: [research, prototype, grilling, task] }',
+    '    status: { enum: [open, in-progress, done, out-of-scope] }',
+    `    map: { type: string, reference: ${WAYFINDING_MAP_TYPE} }`,
+    `    blocked_by: { type: array, items: { type: string, reference: ${WAYFINDING_TICKET_TYPE} } }`,
+    '    assignee:',
+    ...ASSIGNEE,
+    '    conversation: { type: string, format: uuid }',
+    `    app: { type: string, pattern: '${APP_REFERENCE_PATTERN.source}' }`,
+    '  required: [title, kind, status, map, blocked_by]',
+    '  sections:',
+    '    Question: { kind: text }',
+    '    Answer: { kind: text }',
+    '  allOf:',
+    '    - if: { properties: { status: { enum: [in-progress, done, out-of-scope] } }, required: [status] }',
+    '      then: { required: [assignee] }',
+    '      else: { properties: { assignee: false } }',
+    '    - if: { properties: { assignee: { required: [agent] } }, required: [assignee] }',
+    '      else: { properties: { conversation: false } }',
+    '    - if: { properties: { status: { enum: [done, out-of-scope] } }, required: [status] }',
+    '      then: { sections: { Answer: { kind: text, required: true } } }',
+    HOUSE_MODEL_TYPES,
+].join('\n');

package/dist/site.d.ts

@@ -1,4 +1,4 @@
 import type { Adapter } from '@agentshouse/mdruntime';
 import { type HouseSiteTransport } from './transport.js';
-export declare function createSiteAdapter(transport: HouseSiteTransport): Adapter;
+export declare function createSiteAdapter(transport: HouseSiteTransport, snapshot?: boolean): Adapter;
 //# sourceMappingURL=site.d.ts.map