@agentshouse/mdruntime 0.1.0-cf24798931067 → 0.1.0-cf281e8224a5d

package/dist/actions.js

@@ -0,0 +1,251 @@
+import { roomTarget, target } from '@agentshouse/mdmodel';
+import { resendConversations } from './conversation.js';
+import { listingNow } from './listing.js';
+import { locked, lockedRooms } from './locks.js';
+import { scoped } from './models.js';
+import { ABSENT_TARGET, calledResult, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { refuse } from './refusal.js';
+function operationOf(input) {
+    const operation = input?.operation_id;
+    return typeof operation === 'string' ? operation : null;
+}
+export async function readHistory(runtime, locator, path, query = {}) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    if (socket.closed() || session.now().refusal !== null)
+        return UNCERTAIN;
+    await socket.firstDiscovery;
+    if (!session.now().roomsNamed)
+        return UNCERTAIN;
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return UNCERTAIN;
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null)
+        return UNCERTAIN;
+    const since = store.fences.count();
+    const transfer = ['transfer', 'history', locator, path];
+    if (query.revision !== undefined)
+        transfer.push(query.revision);
+    if (query.pageToken !== undefined)
+        transfer.push(query.pageToken);
+    journal.record(transfer.join(' '));
+    try {
+        const result = await socket.history(authorization, {
+            locator,
+            path,
+            ...(query.revision === undefined ? {} : { revision: query.revision }),
+            ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
+        });
+        journal.record(`outcome history ${result.kind}`);
+        if (store.fences.since(locator, since))
+            return failure({ kind: 'room-not-readable', locator });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room, await store.open());
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        return historyAnswer(result);
+    }
+    catch {
+        journal.record('outcome history transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+export async function located(runtime, room, path, destination) {
+    const crossing = roomTarget(destination);
+    const listing = await listingNow(runtime);
+    if (crossing === null) {
+        const named = target(path, destination);
+        return named === null || !listing.has(room) ? null : { room, path: named };
+    }
+    const held = [...listing.values()].find((listed) => listed.handle === crossing.handle);
+    return held === undefined ? null : { room: held.locator, path: crossing.path };
+}
+export async function resolveReference(runtime, room, path, destination) {
+    const { store } = runtime;
+    if (roomTarget(destination) === null && target(path, destination) === null) {
+        return ABSENT_TARGET;
+    }
+    const at = await located(runtime, room, path, destination);
+    if (at === null)
+        return UNREADABLE;
+    if (await locked(runtime, at.room))
+        return LOCKED_UNREADABLE;
+    const held = await store.record(at.room);
+    if (held !== undefined &&
+        (await (await store.open()).entries(held.key, 'visible', [at.path])).length > 0) {
+        return { kind: 'document', ...at };
+    }
+    const history = await readHistory(runtime, at.room, at.path);
+    if (history.kind === 'no-history' || history.kind === 'revision')
+        return ABSENT_TARGET;
+    if (history.kind !== 'history')
+        return history;
+    const [last] = history.revisions;
+    if (last === undefined)
+        return ABSENT_TARGET;
+    return history.deleted === true
+        ? { kind: 'deleted', ...at, revision: last }
+        : { kind: 'document', ...at };
+}
+async function declaredAction({ store }, name) {
+    for (const capability of (await (await store.open()).facts()).capabilities) {
+        for (const action of capability.actions ?? []) {
+            if (action.name === name)
+                return action;
+        }
+    }
+    return undefined;
+}
+async function calledRooms(runtime, name, input) {
+    const member = (await declaredAction(runtime, name))?.room;
+    if (member === undefined || input === null || typeof input !== 'object')
+        return [];
+    const named = input[member];
+    return (Array.isArray(named) ? named : [named]).filter((room) => typeof room === 'string');
+}
+export async function invokeAction(runtime, name, input, dispatching) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    await socket.ready;
+    if (socket.closed() || session.now().refusal !== null)
+        return UNCERTAIN;
+    if ((await declaredAction(runtime, name)) === undefined)
+        return undeclared(name);
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return UNCERTAIN;
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null)
+        return UNCERTAIN;
+    await dispatching?.();
+    journal.record(`transfer action ${name}`);
+    try {
+        const result = await socket.action(authorization, { name, input });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room, await store.open());
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome action ${result.kind}`);
+        if (result.kind === 'rejected')
+            journal.record(`refusal rejected ${result.code}`);
+        return calledResult(result);
+    }
+    catch {
+        journal.record('outcome action transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+export async function readConversationHistory(runtime, request) {
+    const { socket, journal } = runtime;
+    await socket.ready;
+    const stream = socket.conversations();
+    if (socket.closed() || socket.session.now().refusal !== null || stream?.history === undefined) {
+        return UNCERTAIN;
+    }
+    journal.record('transfer conversation history');
+    try {
+        const result = await stream.history(request);
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome conversation history ${result.kind}`);
+        return calledResult(result);
+    }
+    catch {
+        journal.record('outcome conversation history transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+function unsettled(result) {
+    if (result.kind === 'action')
+        return false;
+    return result.retryable && (result.kind !== 'rejected' || result.reset === undefined);
+}
+async function recoveredAction(runtime, name, input) {
+    const { store, socket, recovery } = runtime;
+    const { lanes } = socket;
+    const operation = operationOf(input);
+    if (operation === null)
+        return invokeAction(runtime, name, input);
+    const kept = async () => (await store.open()).keepCall({ operation, name, input });
+    lanes.call(operation);
+    try {
+        let result = await invokeAction(runtime, name, input, kept);
+        if (unsettled(result)) {
+            await recovery.attempt(`action ${operation}`, async () => {
+                if (socket.closed() || socket.session.now().refusal !== null)
+                    return 'done';
+                if (!socket.isOpen())
+                    return 'again';
+                result = await invokeAction(runtime, name, input, kept);
+                return unsettled(result) ? 'again' : 'done';
+            }, { again: true });
+        }
+        if (!unsettled(result))
+            await (await store.open()).dropCall(operation);
+        return result;
+    }
+    finally {
+        lanes.called(operation);
+    }
+}
+export async function called(runtime, name, input) {
+    await runtime.socket.ready;
+    const lockedNow = await lockedRooms(runtime);
+    const room = (await calledRooms(runtime, name, input)).find((one) => lockedNow.includes(one));
+    return room === undefined ? recoveredAction(runtime, name, input) : lockedRoom(room);
+}
+export async function resendCalls(runtime, signal) {
+    const { store, socket } = runtime;
+    const { lanes } = socket;
+    if (!socket.isOpen() || socket.closed() || socket.stopping())
+        return 'done';
+    const local = await store.open();
+    for (const held of await local.calls()) {
+        if (lanes.calling(held.operation))
+            continue;
+        if (socket.closed() || signal.aborted)
+            return 'done';
+        lanes.call(held.operation);
+        try {
+            if (unsettled(await invokeAction(runtime, held.name, held.input)))
+                return 'again';
+            await local.dropCall(held.operation);
+        }
+        finally {
+            lanes.called(held.operation);
+        }
+    }
+    return 'done';
+}
+async function resendPass({ socket, conversations }, signal) {
+    if (!socket.continuing() || !socket.isOpen() || socket.stopping())
+        return 'done';
+    const reading = { complete: true, reachable: true };
+    try {
+        await resendConversations(conversations, reading);
+    }
+    catch {
+        reading.reachable = false;
+    }
+    if (signal.aborted)
+        return 'done';
+    return reading.reachable && reading.complete ? 'done' : 'again';
+}
+export function resendLater(runtime) {
+    if (!runtime.socket.isOpen())
+        return;
+    void runtime.recovery.attempt('resend', (signal) => resendPass(runtime, signal), { again: true });
+}

package/dist/adapter.d.ts

@@ -1,4 +1,6 @@
+import type { SavedFacts, TypedPath } from '@agentshouse/mdmodel';
 import type { ModelResult } from './model.js';
+export type { SavedFacts, TypedPath };
 import type { Open } from './open.js';
 import type { ChangeBatch } from './change.js';
 export type Authorization = object;
@@ -10,14 +12,13 @@ export type TypedSelection = {
     roots: readonly string[];
 };
 export type OperationScopes = {
-    read: readonly string[];
-    sync: readonly string[];
     write: readonly string[];
-    delete: readonly string[];
+    erase: readonly string[];
 };
 export type ReplicaAdmission = {
     selection: string;
     admission: Open<'admitted' | 'unavailable'>;
+    offline: Open<'locked' | 'open'>;
 };
 export type DiscoveredRoom = {
     name: string;
@@ -28,29 +29,27 @@ export type DiscoveredRoom = {
     replica: ReplicaAdmission;
     typedSelection?: TypedSelection;
     providerOwnedPaths: readonly string[];
+    authoredPaths?: readonly string[];
 };
 export type Capability = {
     name: string;
     limits?: readonly ProviderLimit[];
     actions?: readonly ActionDeclaration[];
-    conversationAgents?: ConversationAgents;
-};
-export type ConversationAgents = {
-    locator: string;
-    type: string;
-    identity: string;
-    name: string;
-    retired?: string;
 };
 export type ListedConversation = {
     conversation: string;
     agent: string;
+    agentName: string;
+    agentRetired: boolean;
     name: string;
     created: string;
     finished: string | null;
     outcome: string | null;
+    waiting: boolean;
+    newest: string | null;
+    processEnded: string | null;
 };
-export type ConversationAction = 'conversation.create' | 'conversation.send' | 'conversation.answer' | 'conversation.interrupt' | 'conversation.kill' | 'conversation.cancel' | 'conversation.delete' | 'conversation.history';
+export type ConversationAction = 'conversations/create' | 'conversations/send' | 'conversations/interaction/answer' | 'conversations/interrupt' | 'conversations/kill' | 'conversations/delete';
 export type ConversationMessage = {
     identity: string;
     turn: string;
@@ -141,6 +140,10 @@ export type SessionOption = (SessionOptionNaming & {
     type: 'boolean';
     currentValue: boolean;
 });
+export type RunningSubagent = {
+    description: string;
+    activity: string | null;
+};
 export type ConversationEvent = {
     kind: 'turn';
     conversation: string;
@@ -162,6 +165,22 @@ export type ConversationEvent = {
     kind: 'options';
     conversation: string;
     options: readonly SessionOption[];
+} | {
+    kind: 'starting';
+    conversation: string;
+    step: string | null;
+} | {
+    kind: 'subagents';
+    conversation: string;
+    subagents: readonly RunningSubagent[];
+} | {
+    kind: 'link';
+    conversation: string;
+    connected: boolean;
+} | {
+    kind: 'deliveries';
+    conversation: string;
+    unknown: readonly string[];
 } | {
     kind: 'accepted-message';
     conversation: string;
@@ -172,6 +191,9 @@ export type ConversationEvent = {
 } | {
     kind: 'list';
     entries: readonly ListedConversation[];
+    whole: boolean;
+    more: boolean;
+    cursor: string | null;
 } | {
     kind: 'listed';
     entry: ListedConversation;
@@ -179,14 +201,23 @@ export type ConversationEvent = {
     kind: 'unlisted';
     conversation: string;
 };
+export type ListedAgent = {
+    agent: string;
+    name: string;
+    retired: boolean;
+};
 export type ConversationStream = {
     replicate(conversations: readonly string[]): void;
+    hold(cursor: string | null): void;
     observe(notify: (event: ConversationEvent) => void): () => void;
+    agents?(): Promise<readonly ListedAgent[] | null>;
+    history?(request: ConversationHistoryRequest): Promise<ActionResult>;
 };
 export type ActionDeclaration = {
     name: string;
     inputShape: unknown;
     resultKind: unknown;
+    room?: string;
 };
 export type ProviderLimit = {
     name: string;
@@ -200,7 +231,6 @@ export type HistoryRetention = {
 };
 export type Retention = {
     history: HistoryRetention;
-    outcome: number;
     refreshHorizon: number;
 };
 export type Discovery = {
@@ -229,7 +259,7 @@ export type ProviderRefusal = {
 export type ScopedRefusal = ProviderRefusal & {
     kind: 'scoped-refusal';
     locator: string;
-    scope: Open<'content' | 'sync' | 'model' | 'operation' | 'undisclosed'>;
+    scope: Open<'content' | 'model' | 'operation' | 'undisclosed'>;
 };
 export type AdapterFailure = TransportUncertainty | RoomNotReadable | RevokedAuthorization | ScopedRefusal;
 export type ContractUnavailable = ProviderRefusal & {
@@ -238,49 +268,63 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: 'user';
+    kind: Open<'user' | 'site' | 'inbox' | 'app'>;
     id: string;
     name: string;
-} | {
-    kind: 'site';
+};
+export type Member = {
+    kind: Open<'user'>;
     id: string;
     name: string;
 };
-export type Member = Extract<ChangeAuthor, {
-    kind: 'user';
-}>;
 export type HeadChange = {
     author: ChangeAuthor | null;
     time: string;
 };
-export type RoomAttachment = {
-    reference: string;
-    name: string;
+export type BinaryFile = {
     byteLength: number;
-    mediaType: string | null;
-    entry: unknown;
+    mediaType: string;
+    sha256: string;
 };
 export type BootstrapRequest = {
     locator: string;
     selection: string;
     pageToken?: PageToken;
+    arriving?: (bytes: number) => void;
+    signal?: AbortSignal;
+};
+export type BootstrapPart = {
+    readonly id: string;
+    readonly bytes: number;
+};
+export type BootstrapInventory = {
+    readonly bytes: number;
 };
 export type RoomModels = {
     collection?: ModelResult;
-    selection?: ModelResult;
 };
 export type BootstrapPage = {
     kind: 'bootstrap';
     roomVersion: string;
     models?: RoomModels;
     documents: Readonly<Record<string, string>>;
+    facts: Readonly<Record<string, SavedFacts>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
+    created?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
-    binaryTargets: readonly string[];
-    attachments?: readonly RoomAttachment[];
+    binaryFiles: Readonly<Record<string, BinaryFile>>;
+    folders?: readonly string[];
     pageToken?: PageToken;
+    parts?: readonly BootstrapPart[];
+    bytes?: number;
+};
+export type NotReady = {
+    kind: 'not-ready';
 };
-export type BootstrapResult = BootstrapPage | AdapterFailure;
+export type BootstrapResult = BootstrapPage | {
+    kind: 'beyond-horizon';
+} | NotReady | AdapterFailure;
 export type RefreshRequest = {
     locator: string;
     selection: string;
@@ -292,11 +336,15 @@ export type RefreshPage = {
     roomVersion: string;
     models?: RoomModels;
     documents: Readonly<Record<string, string>>;
+    facts: Readonly<Record<string, SavedFacts>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
+    created?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
-    binaryTargets: readonly string[];
+    binaryFiles: Readonly<Record<string, BinaryFile>>;
     removals: readonly string[];
-    attachments?: readonly RoomAttachment[];
+    folders?: readonly string[];
+    folderRemovals?: readonly string[];
     pageToken?: PageToken;
 };
 export type RefreshResult = {
@@ -307,6 +355,7 @@ export type RefreshResult = {
 export type MutationRequest = {
     locator: string;
     changeBatch: ChangeBatch;
+    file(localId: string): Promise<Blob>;
     upload?: unknown;
 };
 export type RetryableRefusal = ProviderRefusal & {
@@ -317,17 +366,21 @@ export type ServiceMode = Open<'open' | 'write-halted'>;
 export type ServiceModeSignal = {
     observe(notify: (mode: ServiceMode) => void): () => void;
 };
-export type MutationResult = {
-    kind: 'accepted';
+export type AcceptedRoom = {
     roomVersion: string;
     documents: Readonly<Record<string, string>>;
     revisions: Readonly<Record<string, string>>;
+    fileIds?: Readonly<Record<string, string>>;
     changes: Readonly<Record<string, HeadChange>>;
     removals: readonly string[];
-    attachments?: readonly RoomAttachment[];
+    binaryFiles?: Readonly<Record<string, BinaryFile>>;
+};
+export type MutationResult = (AcceptedRoom & {
+    kind: 'accepted';
     author?: string;
     time?: string;
-} | (ProviderRefusal & {
+    destination?: AcceptedRoom;
+}) | (ProviderRefusal & {
     kind: 'conflicted';
     roomVersion?: string;
     affected: Readonly<Record<string, string>>;
@@ -336,14 +389,9 @@ export type MutationResult = {
     affected: Readonly<Record<string, string>>;
 }) | RetryableRefusal | {
     kind: 'write-halted';
-} | {
-    kind: 'expired';
 } | AdapterFailure;
 export type HistoryAuthor = {
-    kind: 'user';
-    id: string;
-} | {
-    kind: 'site';
+    kind: 'user' | 'site' | 'inbox' | 'app';
     id: string;
     name: string;
 };
@@ -351,6 +399,7 @@ export type HistoryRevision = {
     revision: string;
     author: HistoryAuthor;
     time: string;
+    binaryFile?: BinaryFile;
 };
 export type HistoryRequest = {
     locator: string;
@@ -369,6 +418,43 @@ export type HistoryResult = {
 } | {
     kind: 'no-history';
 } | AdapterFailure;
+export type BinaryRequest = {
+    kind: 'path';
+    locator: string;
+    path: string;
+    revision: string;
+};
+export type BinaryResult = {
+    kind: 'binary';
+    body: ReadableStream<Uint8Array>;
+    mediaType: string;
+    sha256?: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type BinaryLinkResult = {
+    kind: 'link';
+    url: string;
+    name: string;
+    mediaType?: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
+export type AttachRequest = {
+    locator: string;
+    name: string;
+    mediaType: string;
+    byteLength: number;
+    sha256: string;
+    blob: Blob;
+};
+export type AttachResult = {
+    kind: 'attached';
+    path: string;
+    revision: string;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+}) | AdapterFailure;
 export type ActionRequest = {
     name: string;
     input: unknown;
@@ -381,48 +467,85 @@ export type ActionResult = {
     kind: 'action';
     result: unknown;
     at?: RoomVersionAt;
+} | (ProviderRefusal & {
+    kind: 'rejected';
+    reset?: string;
+}) | AdapterFailure;
+export type SearchHit = {
+    room: string;
+    path: string;
+    line?: number;
+    snippet?: string;
+};
+export type SearchAsk = {
+    text: string;
+    rooms: readonly string[] | null;
+};
+export type SearchAnswer = {
+    kind: 'found';
+    documents: readonly SearchHit[];
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
 export type HeldRoom = {
     locator: string;
+    roomVersion: string | null;
+};
+export type RoomChange = {
+    kind: 'room-change';
+    locator: string;
+    from: string | null;
     roomVersion: string;
-    documents: Readonly<Record<string, string>>;
-    revisions: Readonly<Record<string, string>>;
-    attachments: readonly RoomAttachment[];
+    read(): Promise<RefreshPage>;
+};
+export type AuthorityChange = {
+    kind: 'authority-changed';
+    rooms: readonly DiscoveredRoom[];
+    left: readonly string[];
+    member?: Member;
 };
 export type RoomStreamEvent = {
     kind: 'opened';
+} | {
+    kind: 'discovered';
+    discovery: Discovery;
 } | {
     kind: 'closed';
     revoked: boolean;
+    lost: boolean;
+    authorityChanged: boolean;
 } | {
-    kind: 'opening';
+    kind: 'caught-up';
     expired: readonly string[];
-} | {
-    kind: 'room-version';
-    locator: string;
-    roomVersion: string;
-};
+} | AuthorityChange | RoomChange;
 export type RoomStream = {
     hold(rooms: readonly HeldRoom[]): void;
-    reopen(): void;
     observe(notify: (event: RoomStreamEvent) => void): () => void;
 };
+export type PathRule = (path: string) => boolean;
 export type Adapter = {
     readonly localSaves?: true;
+    readonly roomTypes?: string;
+    readonly nameableRoomTypes?: readonly string[];
+    readonly typedPaths?: readonly TypedPath[];
+    readonly pathRule?: PathRule;
+    readonly unkeptReads?: readonly string[];
+    readonly leadingReads?: readonly string[];
     authorize(): Promise<Authorization>;
-    discover(authorization: Authorization): Promise<DiscoverResult>;
+    discover?(authorization: Authorization): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
-    refresh(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
+    refresh?(authorization: Authorization, request: RefreshRequest): Promise<RefreshResult>;
     mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
     history(authorization: Authorization, request: HistoryRequest): Promise<HistoryResult>;
+    binary(authorization: Authorization, request: BinaryRequest): Promise<BinaryResult>;
+    link(authorization: Authorization, request: BinaryRequest): Promise<BinaryLinkResult>;
+    attach(authorization: Authorization, request: AttachRequest): Promise<AttachResult>;
     action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
+    search?(authorization: Authorization, request: SearchAsk): Promise<SearchAnswer>;
     reached(locator: string, roomVersion: string, target: string): boolean;
     follows(locator: string, roomVersion: string, next: string): boolean;
     roomStream?: RoomStream;
     conversations?: ConversationStream;
     serviceMode?: ServiceModeSignal;
 };
-export {};
 //# sourceMappingURL=adapter.d.ts.map