@agentshouse/mdruntime 0.1.0-c37ed9e81aef7 → 0.1.0-c382b65c660e7

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,5 @@
-import type { SavedFacts, TypedPath } from '@agentshouse/mdmodel';
+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';
@@ -20,15 +21,18 @@ export type ReplicaAdmission = {
     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;
@@ -38,8 +42,6 @@ export type Capability = {
 export type ListedConversation = {
     conversation: string;
     agent: string;
-    agentName: string;
-    agentRetired: boolean;
     name: string;
     created: string;
     finished: string | null;
@@ -47,8 +49,9 @@ export type ListedConversation = {
     waiting: boolean;
     newest: string | null;
     processEnded: string | null;
+    subject: string | null;
 };
-export type ConversationAction = 'conversations/create' | 'conversations/send' | 'conversations/interaction/answer' | 'conversations/interrupt' | 'conversations/kill' | 'conversations/delete';
+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;
@@ -57,6 +60,7 @@ export type ConversationMessage = {
 };
 export type AcceptedMessage = ConversationMessage & {
     position: string;
+    change: string;
 };
 export type ConversationHistoryRequest = {
     conversations: readonly {
@@ -72,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;
@@ -139,10 +116,6 @@ export type SessionOption = (SessionOptionNaming & {
     type: 'boolean';
     currentValue: boolean;
 });
-export type RunningSubagent = {
-    description: string;
-    activity: string | null;
-};
 export type ConversationEvent = {
     kind: 'turn';
     conversation: string;
@@ -169,9 +142,9 @@ export type ConversationEvent = {
     conversation: string;
     step: string | null;
 } | {
-    kind: 'subagents';
+    kind: 'state';
     conversation: string;
-    subagents: readonly RunningSubagent[];
+    state: SessionState | null;
 } | {
     kind: 'link';
     conversation: string;
@@ -179,6 +152,7 @@ export type ConversationEvent = {
 } | {
     kind: 'deliveries';
     conversation: string;
+    waiting: readonly string[];
     unknown: readonly string[];
 } | {
     kind: 'accepted-message';
@@ -189,6 +163,7 @@ export type ConversationEvent = {
     conversation: string;
 } | {
     kind: 'list';
+    agents: readonly ListedAgent[];
     entries: readonly ListedConversation[];
     whole: boolean;
     more: boolean;
@@ -196,20 +171,68 @@ export type ConversationEvent = {
 } | {
     kind: 'listed';
     entry: ListedConversation;
+} | {
+    kind: 'agent';
+    agent: ListedAgent;
 } | {
     kind: 'unlisted';
     conversation: string;
 };
+export type AgentEnvironment = {
+    identity: string;
+    name: string;
+    state: 'online' | 'offline';
+};
+export type ListedOwner = {
+    readonly user: string;
+    readonly name: string;
+};
+export type ListedSpaceRef = {
+    readonly space_ref: string;
+    readonly name: string;
+};
+export type RoomListEntry = {
+    readonly room_ref: string;
+    readonly room_handle: string;
+    readonly name: string;
+    readonly level: 'search' | 'open' | 'keep';
+    readonly access: 'owner' | 'manage' | 'write' | 'read' | 'public';
+    readonly owner: ListedOwner;
+    readonly created: string;
+    readonly archived?: string;
+    readonly exportable?: true;
+    readonly space?: ListedSpaceRef;
+};
+export type SpaceListEntry = ListedSpaceRef & {
+    readonly owner: ListedOwner;
+    readonly created: string;
+    readonly manages?: true;
+};
+export type RoomList = {
+    readonly rooms: readonly RoomListEntry[];
+    readonly spaces: readonly SpaceListEntry[];
+};
 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 = {
@@ -239,9 +262,12 @@ export type Discovery = {
     providerLimits: readonly ProviderLimit[];
     retention: Retention;
     member?: Member;
+    timeZone?: string | null;
+    roomList?: RoomList;
 };
 export type TransportUncertainty = {
     kind: 'transport-uncertainty';
+    failure?: unknown;
 };
 export type RoomNotReadable = {
     kind: 'room-not-readable';
@@ -310,6 +336,7 @@ export type BootstrapPage = {
     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[];
@@ -337,6 +364,7 @@ export type RefreshPage = {
     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[];
@@ -374,12 +402,9 @@ 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';
@@ -421,6 +446,10 @@ export type BinaryRequest = {
     path: string;
     revision: string;
 };
+export type KeyedRequest = {
+    kind: 'key';
+    link: string;
+};
 export type BinaryResult = {
     kind: 'binary';
     body: ReadableStream<Uint8Array>;
@@ -438,7 +467,7 @@ export type BinaryLinkResult = {
     kind: 'rejected';
 }) | AdapterFailure;
 export type AttachRequest = {
-    locator: string;
+    locator?: string;
     name: string;
     mediaType: string;
     byteLength: number;
@@ -449,6 +478,9 @@ export type AttachResult = {
     kind: 'attached';
     path: string;
     revision: string;
+} | {
+    kind: 'linked';
+    link: string;
 } | (ProviderRefusal & {
     kind: 'rejected';
 }) | AdapterFailure;
@@ -466,6 +498,7 @@ export type ActionResult = {
     at?: RoomVersionAt;
 } | (ProviderRefusal & {
     kind: 'rejected';
+    reset?: string;
 }) | AdapterFailure;
 export type SearchHit = {
     room: string;
@@ -499,6 +532,10 @@ export type AuthorityChange = {
     rooms: readonly DiscoveredRoom[];
     left: readonly string[];
     member?: Member;
+    timeZone?: string | null;
+    roomList?: RoomList & {
+        readonly left: readonly string[];
+    };
 };
 export type RoomStreamEvent = {
     kind: 'opened';
@@ -513,16 +550,21 @@ export type RoomStreamEvent = {
 } | {
     kind: 'caught-up';
     expired: readonly string[];
+} | {
+    kind: 'reported';
 } | AuthorityChange | RoomChange;
 export type RoomStream = {
     hold(rooms: readonly HeldRoom[]): 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 roomTypes?: VerifiedModel;
     readonly typedPaths?: readonly TypedPath[];
+    readonly pathRule?: PathRule;
+    readonly unkeptReads?: readonly string[];
+    readonly leadingReads?: readonly string[];
     authorize(): Promise<Authorization>;
     discover?(authorization: Authorization): Promise<DiscoverResult>;
     bootstrap(authorization: Authorization, request: BootstrapRequest): Promise<BootstrapResult>;
@@ -530,7 +572,7 @@ export type Adapter = {
     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>;
+    link(authorization: Authorization, request: BinaryRequest | KeyedRequest): Promise<BinaryLinkResult>;
     attach(authorization: Authorization, request: AttachRequest): Promise<AttachResult>;
     action(authorization: Authorization, request: ActionRequest): Promise<ActionResult>;
     search?(authorization: Authorization, request: SearchAsk): Promise<SearchAnswer>;