@agentshouse/mdruntime 0.1.0-c069136dcb4e8 → 0.1.0-c076b00ebf42a

package/dist/actions.js

@@ -0,0 +1,302 @@
+import { roomTarget, target } from '@agentshouse/mdmodel';
+import { CATCHING_UP, holdsSubmission, resendConversations } from './conversation.js';
+import { listingNow } from './listing.js';
+import { locked, lockedRooms } from './locks.js';
+import { scoped } from './models.js';
+import { ABSENT_TARGET, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, handedOutcome, UNANSWERED, 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 } = 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();
+    try {
+        const result = await socket.history(authorization, {
+            locator,
+            path,
+            ...(query.revision === undefined ? {} : { revision: query.revision }),
+            ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
+        });
+        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 {
+        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, attempt } = {}) {
+    const { store, socket, retries } = runtime;
+    const { session } = socket;
+    await socket.ready;
+    if (socket.closed() || session.now().refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    if ((await declaredAction(runtime, name)) === undefined)
+        return undeclared(name);
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    await dispatching?.();
+    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');
+        return handedOutcome(retries, attempt, result);
+    }
+    catch (error) {
+        return handedOutcome(retries, attempt, { kind: 'transport-uncertainty', failure: error });
+    }
+}
+export async function readConversationHistory(runtime, request) {
+    const { socket, retries } = runtime;
+    const caught = { step: 'conversations', instance: CATCHING_UP };
+    await socket.ready;
+    const stream = socket.conversations();
+    if (socket.closed() || socket.session.now().refusal !== null || stream?.history === undefined) {
+        return handedOutcome(retries, caught, UNANSWERED);
+    }
+    try {
+        const result = await stream.history(request);
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        return handedOutcome(retries, caught, result);
+    }
+    catch (error) {
+        return handedOutcome(retries, caught, { kind: 'transport-uncertainty', failure: error });
+    }
+}
+function unsettled(result) {
+    if (result.kind === 'action')
+        return false;
+    return result.retryable && (result.kind !== 'rejected' || result.reset === undefined);
+}
+function numberedCall(runtime, name, input, operation, dispatching) {
+    return invokeAction(runtime, name, input, {
+        dispatching,
+        attempt: { step: 'sending', instance: `action ${operation}` },
+    });
+}
+function keptSender(runtime, name, input, operation, resent = false) {
+    const { store, socket } = runtime;
+    const { lanes } = socket;
+    const dispatching = async () => (await store.open()).keepCall({ operation, name, input });
+    let waiting = [];
+    let last = UNCERTAIN;
+    let lost = resent;
+    const tell = (result) => {
+        last = result;
+        const told = waiting;
+        waiting = [];
+        for (const answer of told)
+            answer(result);
+    };
+    const sender = {
+        next: () => new Promise((answer) => waiting.push(answer)),
+        async send() {
+            let result;
+            try {
+                result = await numberedCall(runtime, name, input, operation, dispatching);
+            }
+            catch (error) {
+                tell(last);
+                throw error;
+            }
+            if (unsettled(result))
+                lost = true;
+            else {
+                await (await store.open()).dropCall(operation);
+                lanes.settle(operation, lost);
+            }
+            tell(result);
+            return result;
+        },
+        release() {
+            lanes.sent(operation, sender);
+            tell(last);
+        },
+    };
+    lanes.sending(operation, sender);
+    return sender;
+}
+async function recoveredAction(runtime, name, input, attempt) {
+    const { socket, recovery } = runtime;
+    const operation = operationOf(input);
+    if (operation === null)
+        return invokeAction(runtime, name, input, { attempt });
+    const held = socket.lanes.sender(operation);
+    if (held !== undefined)
+        return held.next();
+    const sender = keptSender(runtime, name, input, operation);
+    let first;
+    try {
+        first = await sender.send();
+    }
+    catch (error) {
+        sender.release();
+        throw error;
+    }
+    if (!unsettled(first)) {
+        sender.release();
+        return first;
+    }
+    void recovery
+        .attempt(`action ${operation}`, async () => {
+        if (socket.closed() || socket.session.now().refusal !== null)
+            return 'done';
+        if (!socket.isOpen())
+            return 'again';
+        return unsettled(await sender.send()) ? 'again' : 'done';
+    }, { again: true })
+        .finally(() => sender.release());
+    return first;
+}
+export async function called(runtime, name, input, attempt) {
+    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, attempt) : lockedRoom(room);
+}
+export async function answeredCall(runtime, operation) {
+    const { store, socket } = runtime;
+    const { lanes } = socket;
+    const held = () => lanes.sender(operation) !== undefined || lanes.unclaimed(operation);
+    if (!held()) {
+        const calls = await (await store.open()).calls();
+        const kept = calls.some((one) => one.operation === operation) ||
+            (await holdsSubmission(runtime.conversations, operation));
+        if (!held() && !kept)
+            return false;
+    }
+    await lanes.settled(operation);
+    return true;
+}
+export async function resendCalls(runtime, signal) {
+    const { store, socket } = runtime;
+    if (!socket.isOpen() || socket.closed() || socket.stopping())
+        return 'done';
+    const local = await store.open();
+    for (const held of await local.calls()) {
+        if (socket.lanes.sender(held.operation) !== undefined)
+            continue;
+        if (socket.closed() || signal.aborted)
+            return 'done';
+        const sender = keptSender(runtime, held.name, held.input, held.operation, true);
+        try {
+            if (unsettled(await sender.send()))
+                return 'again';
+        }
+        finally {
+            sender.release();
+        }
+    }
+    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, VerifiedModel } 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,22 +14,25 @@ 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;
@@ -36,16 +42,16 @@ export type Capability = {
 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;
+    subject: 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;
@@ -54,6 +60,7 @@ export type ConversationMessage = {
 };
 export type AcceptedMessage = ConversationMessage & {
     position: string;
+    change: string;
 };
 export type ConversationHistoryRequest = {
     conversations: readonly {
@@ -69,37 +76,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;
@@ -161,6 +141,10 @@ export type ConversationEvent = {
     kind: 'starting';
     conversation: string;
     step: string | null;
+} | {
+    kind: 'state';
+    conversation: string;
+    state: SessionState | null;
 } | {
     kind: 'link';
     conversation: string;
@@ -168,6 +152,7 @@ export type ConversationEvent = {
 } | {
     kind: 'deliveries';
     conversation: string;
+    waiting: readonly string[];
     unknown: readonly string[];
 } | {
     kind: 'accepted-message';
@@ -178,23 +163,48 @@ export type ConversationEvent = {
     conversation: string;
 } | {
     kind: 'list';
+    agents: readonly ListedAgent[];
     entries: readonly ListedConversation[];
+    whole: boolean;
+    more: boolean;
+    cursor: string | null;
 } | {
     kind: 'listed';
     entry: ListedConversation;
+} | {
+    kind: 'agent';
+    agent: ListedAgent;
 } | {
     kind: 'unlisted';
     conversation: string;
 };
+export type AgentEnvironment = {
+    identity: string;
+    name: string;
+    state: 'online' | 'offline';
+};
 export type ListedAgent = {
-    agent: string;
+    id: string;
     name: string;
-    retired: boolean;
+    revision: number;
+    environment: string;
+    environment_name: string;
+    environment_connected: boolean;
+    launch_directory: string;
+    cli: string;
+    model: string | null;
+    effort: string | null;
+    mode: string | null;
+    base_instructions: string;
+    in_telegram: boolean;
+    created: string;
+    retired_at: string | null;
 };
 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;
@@ -214,7 +224,6 @@ export type HistoryRetention = {
 };
 export type Retention = {
     history: HistoryRetention;
-    outcome: number;
     refreshHorizon: number;
 };
 export type Discovery = {
@@ -224,13 +233,10 @@ 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';
+    failure?: unknown;
 };
 export type RoomNotReadable = {
     kind: 'room-not-readable';
@@ -274,25 +280,17 @@ 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;
     arriving?: (bytes: number) => void;
     signal?: AbortSignal;
 };
+export type BootstrapPart = {
+    readonly id: string;
+    readonly bytes: number;
+};
 export type BootstrapInventory = {
     readonly bytes: number;
 };
@@ -304,17 +302,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;
+    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;
@@ -326,8 +330,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[];
@@ -365,27 +371,18 @@ export type AcceptedRoom = {
 };
 export type MutationResult = (AcceptedRoom & {
     kind: 'accepted';
-    author?: string;
-    time?: string;
     destination?: AcceptedRoom;
 }) | (ProviderRefusal & {
     kind: 'conflicted';
-    roomVersion?: string;
     affected: Readonly<Record<string, string>>;
 }) | (ProviderRefusal & {
     kind: 'rejected';
     affected: Readonly<Record<string, string>>;
 }) | RetryableRefusal | {
     kind: 'write-halted';
-} | {
-    kind: 'expired';
-    restored?: true;
 } | AdapterFailure;
 export type HistoryAuthor = {
-    kind: 'user';
-    id: string;
-} | {
-    kind: 'site' | 'inbox' | 'app';
+    kind: 'user' | 'site' | 'inbox' | 'app';
     id: string;
     name: string;
 };
@@ -461,45 +458,71 @@ 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;
+    roomVersion: string | null;
 };
 export type RoomChange = {
     kind: 'room-change';
     locator: string;
-    from: 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 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;
-} | RoomChange;
+} | 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 exhaustiveDiscovery?: true;
-    readonly roomTypes?: string;
-    readonly nameableRoomTypes?: readonly string[];
+    readonly roomTypes?: VerifiedModel;
+    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>;
     mutate(authorization: Authorization, request: MutationRequest, keep: (upload: unknown) => Promise<void>): Promise<MutationResult>;
@@ -508,11 +531,11 @@ export type Adapter = {
     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