@agentshouse/mdruntime 0.1.0-c7f53cda5b000 → 0.1.0-c806ecaf4afed

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, presence, 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 = presence.losses();
+    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 (presence.lostSince(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.locator, room.declaration);
+        }
+        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.locator, room.declaration);
+        }
+        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,7 @@
+import type { SavedFacts, TypedPath } from '@agentshouse/mdmodel';
+import type { Operation, SessionState } from '@agentshouse/session-content';
 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;
@@ -11,46 +14,45 @@ export type TypedSelection = {
 };
 export type OperationScopes = {
     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;
-    locator: string;
-    handle: string;
-    roomVersion: string;
-    operations: OperationScopes;
-    replica: ReplicaAdmission;
-    typedSelection?: TypedSelection;
-    providerOwnedPaths: readonly string[];
+export type RoomDeclaration = {
+    readonly name: string;
+    readonly handle: string;
+    readonly operations: OperationScopes;
+    readonly replica: ReplicaAdmission;
+    readonly typedSelection: TypedSelection | null;
+    readonly providerOwnedPaths: readonly string[];
+    readonly authoredPaths: readonly string[];
+};
+export type DiscoveredRoom = RoomDeclaration & {
+    readonly locator: string;
+    readonly roomVersion: 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' | 'conversations/take-out' | 'conversations/rename' | 'conversations/option/set' | 'conversations/retry' | 'agent-functions/decide';
 export type ConversationMessage = {
     identity: string;
     turn: string;
@@ -59,6 +61,7 @@ export type ConversationMessage = {
 };
 export type AcceptedMessage = ConversationMessage & {
     position: string;
+    change: string;
 };
 export type ConversationHistoryRequest = {
     conversations: readonly {
@@ -74,37 +77,10 @@ export type ConversationHistoryPage = {
 export type ConversationHistories = {
     histories: readonly ConversationHistoryPage[];
 };
-export type TurnContext = {
-    used: number;
-    window: number;
-};
 export type TurnOperation = {
     op: 'begin';
     at: string;
-} | {
-    op: 'start';
-    index: number;
-    part: unknown;
-} | {
-    op: 'append';
-    index: number;
-    text: string;
-} | {
-    op: 'status';
-    index: number;
-    status: string;
-    result: unknown;
-} | {
-    op: 'count';
-    index: number;
-    count: number;
-} | {
-    op: 'plan';
-    index: number;
-    entries: readonly unknown[];
-} | ({
-    op: 'context';
-} & TurnContext);
+} | Operation;
 export type ProcessCommand = {
     [field: string]: unknown;
     name: string;
@@ -166,6 +142,10 @@ export type ConversationEvent = {
     kind: 'starting';
     conversation: string;
     step: string | null;
+} | {
+    kind: 'state';
+    conversation: string;
+    state: SessionState | null;
 } | {
     kind: 'link';
     conversation: string;
@@ -173,6 +153,7 @@ export type ConversationEvent = {
 } | {
     kind: 'deliveries';
     conversation: string;
+    waiting: readonly string[];
     unknown: readonly string[];
 } | {
     kind: 'accepted-message';
@@ -184,6 +165,9 @@ export type ConversationEvent = {
 } | {
     kind: 'list';
     entries: readonly ListedConversation[];
+    whole: boolean;
+    more: boolean;
+    cursor: string | null;
 } | {
     kind: 'listed';
     entry: ListedConversation;
@@ -191,9 +175,24 @@ export type ConversationEvent = {
     kind: 'unlisted';
     conversation: string;
 };
+export type AgentEnvironment = {
+    identity: string;
+    name: string;
+    state: 'online' | 'offline';
+};
+export type ListedAgent = {
+    agent: string;
+    name: string;
+    retired: boolean;
+    cli: string;
+    environment: AgentEnvironment;
+};
 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;
@@ -213,7 +212,6 @@ export type HistoryRetention = {
 };
 export type Retention = {
     history: HistoryRetention;
-    outcome: number;
     refreshHorizon: number;
 };
 export type Discovery = {
@@ -223,10 +221,6 @@ export type Discovery = {
     providerLimits: readonly ProviderLimit[];
     retention: Retention;
     member?: Member;
-    covered?: readonly string[];
-};
-export type DiscoveryScope = {
-    readonly authorities: readonly string[];
 };
 export type TransportUncertainty = {
     kind: 'transport-uncertainty';
@@ -255,7 +249,7 @@ export type ContractUnavailable = ProviderRefusal & {
 export type DiscoverResult = Discovery | TransportUncertainty | RevokedAuthorization | ContractUnavailable;
 export type PageToken = string;
 export type ChangeAuthor = {
-    kind: Open<'user' | 'site' | 'inbox'>;
+    kind: Open<'user' | 'site' | 'inbox' | 'app'>;
     id: string;
     name: string;
 };
@@ -273,27 +267,18 @@ export type BinaryFile = {
     mediaType: string;
     sha256: string;
 };
-export type HeldFile = {
-    readonly path: string;
-    readonly revision: string;
-};
-export type HeldContent = {
-    files(after: string | null, limit: number): Promise<readonly HeldFile[]>;
-    contents(paths: readonly string[]): Promise<ReadonlyMap<string, {
-        readonly content: string;
-        readonly revision: string;
-    }>>;
-};
 export type BootstrapRequest = {
     locator: string;
     selection: string;
     pageToken?: PageToken;
-    held?: HeldContent;
-    received?: Uint8Array;
     arriving?: (bytes: number) => void;
+    signal?: AbortSignal;
+};
+export type BootstrapPart = {
+    readonly id: string;
+    readonly bytes: number;
 };
 export type BootstrapInventory = {
-    readonly parts: number;
     readonly bytes: number;
 };
 export type RoomModels = {
@@ -304,18 +289,23 @@ export type BootstrapPage = {
     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>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     folders?: readonly string[];
     pageToken?: PageToken;
-    inventory?: BootstrapInventory;
-    received?: Uint8Array;
+    parts?: readonly BootstrapPart[];
+    bytes?: number;
+};
+export type NotReady = {
+    kind: 'not-ready';
 };
 export type BootstrapResult = BootstrapPage | {
     kind: 'beyond-horizon';
-} | AdapterFailure;
+} | NotReady | AdapterFailure;
 export type RefreshRequest = {
     locator: string;
     selection: string;
@@ -327,8 +317,10 @@ 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>>;
     binaryFiles: Readonly<Record<string, BinaryFile>>;
     removals: readonly string[];
@@ -378,15 +370,9 @@ export type MutationResult = (AcceptedRoom & {
     affected: Readonly<Record<string, string>>;
 }) | RetryableRefusal | {
     kind: 'write-halted';
-} | {
-    kind: 'expired';
-    restored?: true;
 } | AdapterFailure;
 export type HistoryAuthor = {
-    kind: 'user';
-    id: string;
-} | {
-    kind: 'site' | 'inbox';
+    kind: 'user' | 'site' | 'inbox' | 'app';
     id: string;
     name: string;
 };
@@ -462,70 +448,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;
+    read(): Promise<RefreshPage>;
+};
+export type AuthorityChange = {
+    kind: 'authority-changed';
+    rooms: readonly DiscoveredRoom[];
+    left: readonly string[];
+    member?: Member;
 };
-export type HeldRevisions = (locator: string, paths: readonly string[]) => Promise<ReadonlyMap<string, string>>;
 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: 'authority-changed';
-    scope?: DiscoveryScope;
-} | {
-    kind: 'room-version';
-    locator: string;
-    roomVersion: string;
-};
-export type KeptReceipt = {
-    key: string;
-    head: unknown;
-};
-export type StreamReceipts = {
-    heads(): Promise<readonly KeptReceipt[]>;
-    parts(key: string, count: number): Promise<readonly unknown[]>;
-    keep(key: string, head: unknown, part?: {
-        index: number;
-        value: unknown;
-    }): Promise<void>;
-    drop(keys: readonly string[]): Promise<void>;
-};
+} | AuthorityChange | RoomChange;
 export type RoomStream = {
     hold(rooms: readonly HeldRoom[]): void;
-    reopen(): void;
-    published(locator: string, roomVersion: string): void;
-    observe(notify: (event: RoomStreamEvent) => void, receipts: StreamReceipts, revisions: HeldRevisions): () => void;
+    observe(notify: (event: RoomStreamEvent) => void): () => void;
 };
+export type PathRule = (path: string) => boolean;
 export type Adapter = {
     readonly localSaves?: true;
-    readonly exhaustiveDiscovery?: 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, scope?: DiscoveryScope): 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