@agentshouse/mdruntime 0.1.0-alpha.8 → 0.1.0-c436a939f2119

package/dist/conversation.d.ts

@@ -0,0 +1,79 @@
+import type { ConversationAction, ConversationCards, ConversationEvent, ConversationMessage, ConversationStream, PlanStep, ProcessCommand, SessionOption, WorkingNote } from './adapter.js';
+import { type ChangeSet } from './change-set.js';
+import { type ChatDraftFile } from './file.js';
+import type { CallResult } from './outcome.js';
+import type { DocumentResult, QueryDocument } from './query.js';
+import type { SearchedMessage } from './search.js';
+import type { CycleProgress } from './status.js';
+import type { ChatDraftRecord, HeldConversation, RuntimeStore } from './store.js';
+export type ConversationEntry = {
+    conversation: string;
+    card: Required<QueryDocument>;
+    agent: Required<QueryDocument> | null;
+};
+export type GrowingText = {
+    turn: string;
+    text: string;
+};
+export type ChatDraft = {
+    text: string;
+    files: readonly ChatDraftFile[];
+};
+export type ConversationOptions = {
+    limit?: number;
+};
+export type ConversationView = {
+    conversation: string;
+    messages: readonly ConversationMessage[];
+    growingText: GrowingText | null;
+    workingNote: WorkingNote | null;
+    plan: readonly PlanStep[] | null;
+    questions: readonly unknown[];
+    process: {
+        running: boolean;
+    } | null;
+    commands: readonly ProcessCommand[];
+    options: readonly SessionOption[];
+    chatDraft: ChatDraft | null;
+};
+export type ConversationSurface = {
+    list(): Promise<readonly ConversationEntry[]>;
+    read(conversation: string, options?: ConversationOptions): Promise<ConversationView>;
+    create(input: unknown): Promise<CallResult>;
+    send(conversation: string): Promise<CallResult>;
+    answer(conversation: string, answer: unknown): Promise<CallResult>;
+    interrupt(conversation: string): Promise<CallResult>;
+    kill(conversation: string): Promise<CallResult>;
+    cancel(conversation: string, turn: string): Promise<CallResult>;
+    delete(conversation: string): Promise<CallResult>;
+};
+export type ChatDraftSurface = {
+    write(conversation: string, draft: ChatDraft): Promise<void>;
+    discard(conversation: string): Promise<void>;
+};
+export type ConversationDependencies = {
+    cards(): ConversationCards | undefined;
+    documents(locator: string): Promise<DocumentResult>;
+    call(name: ConversationAction, input: unknown): Promise<CallResult>;
+    durably<T>(work: (local: RuntimeStore) => Promise<T>): Promise<T>;
+    stream(): ConversationStream | undefined;
+    publish(set: ChangeSet): void;
+    closed(): boolean;
+};
+export type ConversationStore = {
+    surface: ConversationSurface;
+    chatDraft: ChatDraftSurface;
+    hydrate(held: readonly HeldConversation[], drafts: readonly ChatDraftRecord[]): void;
+    reconcile(): Promise<void>;
+    catchUp(progress: CycleProgress): Promise<void>;
+    current(): boolean;
+    reconnected(): void;
+    watch(conversation: string, options: ConversationOptions, deliver: (view: ConversationView) => void): () => void;
+    changed(set: ChangeSet): void;
+    receive(event: ConversationEvent): void;
+    messages(): readonly SearchedMessage[];
+    message(conversation: string, identity: string): SearchedMessage | null;
+    close(): void;
+};
+export declare function createConversationStore(deps: ConversationDependencies): ConversationStore;
+//# sourceMappingURL=conversation.d.ts.map

package/dist/conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation.d.ts","sourceRoot":"","sources":["../src/conversation.ts"],"names":[],"mappings":"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"}

package/dist/conversation.js

@@ -0,0 +1,557 @@
+import { conversationChangeSet } from './change-set.js';
+import { declaredFile } from './file.js';
+const QUIET = {
+    growingText: null,
+    plan: null,
+    workingNote: null,
+    questions: [],
+    process: null,
+    commands: [],
+    options: [],
+};
+function ordered(left, right) {
+    if (left.position !== right.position)
+        return left.position < right.position ? -1 : 1;
+    if (left.identity !== right.identity)
+        return left.identity < right.identity ? -1 : 1;
+    return 0;
+}
+function merged(held, arriving) {
+    const byIdentity = new Map(held.map((message) => [message.identity, message]));
+    for (const message of arriving)
+        byIdentity.set(message.identity, message);
+    return [...byIdentity.values()].sort(ordered);
+}
+function acceptedMessage(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const record = value;
+    if (typeof record.identity !== 'string' ||
+        typeof record.turn !== 'string' ||
+        typeof record.position !== 'string' ||
+        typeof record.text !== 'string') {
+        return null;
+    }
+    return {
+        identity: record.identity,
+        turn: record.turn,
+        position: record.position,
+        text: record.text,
+        message: structuredClone(record.message),
+    };
+}
+function historyPage(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const record = value;
+    if (typeof record.conversation !== 'string' || !Array.isArray(record.messages))
+        return null;
+    if (record.next !== undefined && typeof record.next !== 'string')
+        return null;
+    const messages = [];
+    for (const entry of record.messages) {
+        const message = acceptedMessage(entry);
+        if (message === null)
+            return null;
+        messages.push(message);
+    }
+    return {
+        conversation: record.conversation,
+        messages,
+        ...(record.next === undefined ? {} : { next: record.next }),
+    };
+}
+function historyPages(result) {
+    if (result.kind !== 'action')
+        return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null)
+        return null;
+    const { histories } = answer;
+    if (!Array.isArray(histories))
+        return null;
+    const pages = [];
+    for (const entry of histories) {
+        const page = historyPage(entry);
+        if (page === null)
+            return null;
+        pages.push(page);
+    }
+    return pages;
+}
+function turnOf(result) {
+    if (result.kind !== 'action')
+        return null;
+    const answer = result.result;
+    if (typeof answer !== 'object' || answer === null)
+        return null;
+    const record = answer;
+    return typeof record.turn === 'string' ? record.turn : null;
+}
+function limitOf(options) {
+    const { limit } = options;
+    if (limit === undefined)
+        return undefined;
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw new Error(`conversation limit must be a non-negative integer, got ${String(limit)}`);
+    }
+    return limit;
+}
+export function createConversationStore(deps) {
+    const messages = new Map();
+    const reads = new Map();
+    const drafts = new Map();
+    const sending = new Map();
+    const behind = new Set();
+    const gaps = new Map();
+    const lives = new Map();
+    const views = new Map();
+    let replicated = new Set();
+    let handedReplicated;
+    function liveOf(conversation) {
+        return lives.get(conversation) ?? QUIET;
+    }
+    function viewOf(conversation, limit) {
+        const held = messages.get(conversation) ?? [];
+        const shown = limit === undefined ? held : held.slice(Math.max(0, held.length - limit));
+        const draft = drafts.get(conversation);
+        const facts = liveOf(conversation);
+        return {
+            conversation,
+            messages: shown.map(({ identity, turn, text, message }) => ({
+                identity,
+                turn,
+                text,
+                message: structuredClone(message),
+            })),
+            growingText: facts.growingText === null ? null : { ...facts.growingText },
+            workingNote: facts.workingNote === null ? null : { ...facts.workingNote },
+            plan: structuredClone(facts.plan?.plan ?? null),
+            questions: structuredClone(facts.questions),
+            process: facts.process === null ? null : { ...facts.process },
+            commands: structuredClone(facts.commands),
+            options: structuredClone(facts.options),
+            chatDraft: draft === undefined || draft.turn !== null || sending.get(conversation)?.draft === draft
+                ? null
+                : { text: draft.text, files: [...draft.files] },
+        };
+    }
+    function emit(conversation) {
+        if (deps.closed())
+            return;
+        for (const view of views.values()) {
+            if (view.conversation !== conversation)
+                continue;
+            const ready = [...view.watchers].filter((watcher) => watcher.ready);
+            if (ready.length === 0)
+                continue;
+            const value = viewOf(conversation, view.limit);
+            for (const watcher of ready)
+                watcher.notify(value);
+        }
+    }
+    function live(conversation, change) {
+        lives.set(conversation, { ...liveOf(conversation), ...change });
+        emit(conversation);
+    }
+    function sealTurns(conversation, turns) {
+        const held = lives.get(conversation);
+        if (held === undefined)
+            return false;
+        const growingText = held.growingText !== null && turns.has(held.growingText.turn) ? null : held.growingText;
+        const plan = held.plan !== null && turns.has(held.plan.turn) ? null : held.plan;
+        if (growingText === held.growingText && plan === held.plan)
+            return false;
+        lives.set(conversation, { ...held, growingText, plan });
+        return true;
+    }
+    function handReplicated() {
+        const stream = deps.stream();
+        if (stream === undefined)
+            return;
+        const held = [...replicated].sort();
+        const named = JSON.stringify(held);
+        if (named === handedReplicated)
+            return;
+        handedReplicated = named;
+        stream.replicate(held);
+    }
+    async function documented() {
+        const declaration = deps.cards();
+        if (declaration === undefined)
+            return [];
+        const { documents } = await deps.documents(declaration.locator);
+        return documents.filter((document) => typeof document.type === 'string');
+    }
+    function carded(documents) {
+        const declaration = deps.cards();
+        if (declaration === undefined)
+            return [];
+        const cards = [];
+        for (const card of documents) {
+            if (card.type !== declaration.type)
+                continue;
+            const identity = card.fields[declaration.identity];
+            if (typeof identity === 'string')
+                cards.push({ conversation: identity, card });
+        }
+        return cards;
+    }
+    async function remove(leaving) {
+        await deps.durably(async (local) => {
+            await local.dropConversations(leaving);
+            const removed = [];
+            const changed = [];
+            for (const conversation of leaving) {
+                for (const message of messages.get(conversation) ?? []) {
+                    removed.push({ conversation, identity: message.identity });
+                }
+                if (messages.has(conversation) || drafts.has(conversation) || lives.has(conversation)) {
+                    changed.push(conversation);
+                }
+                messages.delete(conversation);
+                reads.delete(conversation);
+                drafts.delete(conversation);
+                behind.delete(conversation);
+                lives.delete(conversation);
+            }
+            if (changed.length > 0)
+                deps.publish(conversationChangeSet(removed, changed));
+        });
+    }
+    function gap(conversation) {
+        gaps.set(conversation, (gaps.get(conversation) ?? 0) + 1);
+        behind.add(conversation);
+    }
+    function keep(conversation, message) {
+        return deps.durably(async (local) => {
+            if (!replicated.has(conversation))
+                return;
+            const read = reads.get(conversation);
+            const advances = read !== undefined &&
+                !behind.has(conversation) &&
+                (read === null || message.position > read);
+            const sealed = drafts.get(conversation)?.turn === message.turn;
+            await local.keepMessages({
+                conversation,
+                messages: [message],
+                ...(advances ? { read: message.position } : {}),
+                sealed,
+            });
+            messages.set(conversation, merged(messages.get(conversation) ?? [], [message]));
+            if (advances)
+                reads.set(conversation, message.position);
+            if (sealed)
+                drafts.delete(conversation);
+            sealTurns(conversation, new Set([message.turn]));
+            deps.publish(conversationChangeSet([{ conversation, identity: message.identity }], [conversation]));
+        });
+    }
+    async function readHistories(conversations) {
+        const generations = new Map(conversations.map((one) => [one, gaps.get(one) ?? 0]));
+        const starts = new Map(conversations.map((one) => [one, reads.get(one)]));
+        const arriving = new Map();
+        const complete = new Set();
+        let asking = conversations.map((conversation) => ({
+            conversation,
+            after: starts.get(conversation) ?? undefined,
+        }));
+        while (asking.length > 0) {
+            const result = await deps.call('conversation.history', {
+                conversations: asking.map(({ conversation, after }) => ({
+                    conversation,
+                    ...(after === undefined ? {} : { after }),
+                })),
+            });
+            const pages = historyPages(result);
+            if (pages === null)
+                return result;
+            const asked = new Set(asking.map(({ conversation }) => conversation));
+            const following = [];
+            for (const page of pages) {
+                if (!asked.has(page.conversation))
+                    continue;
+                arriving.set(page.conversation, [
+                    ...(arriving.get(page.conversation) ?? []),
+                    ...page.messages,
+                ]);
+                if (page.next === undefined)
+                    complete.add(page.conversation);
+                else
+                    following.push({ conversation: page.conversation, after: page.next });
+            }
+            asking = following;
+        }
+        for (const [conversation, held] of arriving) {
+            if (!complete.has(conversation))
+                continue;
+            await keepHistory(conversation, held, starts.get(conversation), generations.get(conversation) ?? 0);
+        }
+        return null;
+    }
+    function keepHistory(conversation, arriving, from, generation) {
+        return deps.durably(async (local) => {
+            if (!replicated.has(conversation))
+                return;
+            const newest = arriving.reduce((top, message) => (top === null || message.position > top ? message.position : top), from ?? null);
+            const turn = drafts.get(conversation)?.turn;
+            const sealed = arriving.some((message) => message.turn === turn);
+            await local.keepMessages({ conversation, messages: arriving, read: newest, sealed });
+            messages.set(conversation, merged(messages.get(conversation) ?? [], arriving));
+            reads.set(conversation, newest);
+            if (sealed)
+                drafts.delete(conversation);
+            sealTurns(conversation, new Set(arriving.map((message) => message.turn)));
+            if ((gaps.get(conversation) ?? 0) === generation)
+                behind.delete(conversation);
+            if (arriving.length > 0 || sealed) {
+                deps.publish(conversationChangeSet(arriving.map((message) => ({ conversation, identity: message.identity })), [conversation]));
+            }
+        });
+    }
+    function withDraft(conversation, next) {
+        return deps.durably(async (local) => {
+            const following = next(drafts.get(conversation));
+            if (following === undefined)
+                return;
+            if (following === null) {
+                await local.dropChatDraft(conversation);
+                drafts.delete(conversation);
+            }
+            else {
+                await local.keepChatDraft(following);
+                drafts.set(conversation, following);
+            }
+            deps.publish(conversationChangeSet([], [conversation]));
+        });
+    }
+    function invoke(name, conversation, extra = {}) {
+        return deps.call(name, { conversation, ...extra });
+    }
+    const surface = {
+        async list() {
+            const declaration = deps.cards();
+            if (declaration === undefined)
+                return [];
+            const documents = await documented();
+            const entries = carded(documents).map(({ conversation, card }) => ({
+                conversation,
+                card,
+                agent: documents.find((document) => document.backlinks.some((backlink) => backlink.path === card.path && backlink.field === declaration.agent)) ?? null,
+            }));
+            entries.sort((left, right) => (left.conversation < right.conversation ? -1 : 1));
+            return entries;
+        },
+        async read(conversation, options = {}) {
+            const limit = limitOf(options);
+            return deps.durably(() => Promise.resolve(viewOf(conversation, limit)));
+        },
+        create(input) {
+            return deps.call('conversation.create', input);
+        },
+        async send(conversation) {
+            const draft = drafts.get(conversation);
+            const pending = draft === undefined ? undefined : { draft };
+            if (pending !== undefined) {
+                sending.set(conversation, pending);
+                deps.publish(conversationChangeSet([], [conversation]));
+            }
+            try {
+                const files = await Promise.all((draft?.files ?? []).map(async (file) => ({
+                    ...(await declaredFile(file)),
+                    blob: file.blob,
+                })));
+                const result = await invoke('conversation.send', conversation, {
+                    text: draft?.text ?? '',
+                    files,
+                });
+                const turn = turnOf(result);
+                if (turn === null || draft === undefined)
+                    return result;
+                await withDraft(conversation, (current) => {
+                    if (current !== draft)
+                        return undefined;
+                    const sealed = (messages.get(conversation) ?? []).some((message) => message.turn === turn);
+                    return sealed ? null : { ...draft, turn };
+                });
+                return result;
+            }
+            finally {
+                if (pending !== undefined && sending.get(conversation) === pending) {
+                    sending.delete(conversation);
+                    if (drafts.get(conversation) === draft) {
+                        deps.publish(conversationChangeSet([], [conversation]));
+                    }
+                }
+            }
+        },
+        answer(conversation, answer) {
+            return invoke('conversation.answer', conversation, { answer });
+        },
+        interrupt(conversation) {
+            return invoke('conversation.interrupt', conversation);
+        },
+        kill(conversation) {
+            return invoke('conversation.kill', conversation);
+        },
+        async cancel(conversation, turn) {
+            const result = await invoke('conversation.cancel', conversation, { turn });
+            if (result.kind !== 'action')
+                return result;
+            await withDraft(conversation, (current) => current === undefined || current.turn !== turn ? undefined : { ...current, turn: null });
+            return result;
+        },
+        delete(conversation) {
+            return invoke('conversation.delete', conversation);
+        },
+    };
+    const chatDraft = {
+        write(conversation, draft) {
+            return withDraft(conversation, () => ({
+                conversation,
+                text: draft.text,
+                files: [...draft.files],
+                turn: null,
+            }));
+        },
+        discard(conversation) {
+            return withDraft(conversation, (current) => (current === undefined ? undefined : null));
+        },
+    };
+    return {
+        surface,
+        chatDraft,
+        hydrate(held, stored) {
+            messages.clear();
+            reads.clear();
+            for (const entry of held) {
+                messages.set(entry.conversation, [...entry.messages].sort(ordered));
+                if (entry.read !== undefined)
+                    reads.set(entry.conversation, entry.read);
+            }
+            drafts.clear();
+            for (const record of stored)
+                drafts.set(record.conversation, record);
+        },
+        async reconcile() {
+            const named = new Set(carded(await documented()).map((entry) => entry.conversation));
+            const leaving = [
+                ...new Set([...replicated, ...messages.keys(), ...reads.keys(), ...drafts.keys()]),
+            ].filter((conversation) => !named.has(conversation));
+            for (const conversation of named) {
+                if (!replicated.has(conversation))
+                    behind.add(conversation);
+            }
+            replicated = named;
+            handReplicated();
+            if (leaving.length > 0)
+                await remove(leaving);
+        },
+        async catchUp(progress) {
+            const reading = [...behind].filter((conversation) => replicated.has(conversation)).sort();
+            if (reading.length > 0 && !deps.closed()) {
+                const failed = await readHistories(reading);
+                if (failed?.kind === 'transport-uncertainty')
+                    progress.reachable = false;
+            }
+            if (behind.size > 0)
+                progress.complete = false;
+        },
+        current() {
+            return behind.size === 0;
+        },
+        reconnected() {
+            for (const conversation of replicated)
+                gap(conversation);
+        },
+        watch(conversation, options, deliver) {
+            const limit = limitOf(options);
+            const key = JSON.stringify([conversation, limit ?? null]);
+            const view = views.get(key) ?? { conversation, limit, watchers: new Set() };
+            views.set(key, view);
+            const watcher = { notify: deliver, ready: false };
+            view.watchers.add(watcher);
+            void deps
+                .durably(() => Promise.resolve())
+                .then(() => {
+                if (deps.closed() || !view.watchers.has(watcher))
+                    return;
+                watcher.ready = true;
+                watcher.notify(viewOf(conversation, limit));
+            })
+                .catch(() => { });
+            return () => {
+                if (!view.watchers.delete(watcher))
+                    return;
+                if (view.watchers.size === 0)
+                    views.delete(key);
+            };
+        },
+        changed(set) {
+            for (const conversation of set.conversations)
+                emit(conversation);
+        },
+        receive(event) {
+            if (deps.closed())
+                return;
+            const { conversation } = event;
+            if (event.kind === 'gap') {
+                if (replicated.has(conversation))
+                    gap(conversation);
+                if (lives.delete(conversation))
+                    emit(conversation);
+                return;
+            }
+            if (event.kind === 'growing-text') {
+                live(conversation, { growingText: { turn: event.turn, text: event.text } });
+                return;
+            }
+            if (event.kind === 'plan') {
+                live(conversation, { plan: { turn: event.turn, plan: structuredClone(event.plan) } });
+                return;
+            }
+            if (event.kind === 'working-note') {
+                live(conversation, {
+                    workingNote: event.note === null ? null : { noteId: event.note.noteId, text: event.note.text },
+                });
+                return;
+            }
+            if (event.kind === 'questions') {
+                live(conversation, { questions: structuredClone(event.questions) });
+                return;
+            }
+            if (event.kind === 'process') {
+                live(conversation, { process: { running: event.running } });
+                return;
+            }
+            if (event.kind === 'commands') {
+                live(conversation, { commands: structuredClone(event.commands) });
+                return;
+            }
+            if (event.kind === 'options') {
+                live(conversation, { options: structuredClone(event.options) });
+                return;
+            }
+            const arriving = acceptedMessage(event.message);
+            if (arriving === null)
+                return;
+            if (replicated.has(conversation)) {
+                void keep(conversation, arriving).catch(() => { });
+                return;
+            }
+            if (sealTurns(conversation, new Set([arriving.turn])))
+                emit(conversation);
+        },
+        messages() {
+            return [...messages].flatMap(([conversation, held]) => held.map(({ identity, text }) => ({ conversation, identity, text })));
+        },
+        message(conversation, identity) {
+            const held = messages.get(conversation)?.find((message) => message.identity === identity);
+            return held === undefined ? null : { conversation, identity, text: held.text };
+        },
+        close() {
+            views.clear();
+            lives.clear();
+        },
+    };
+}

package/dist/durability.d.ts

@@ -1,4 +1,9 @@
-export declare function requestPersistentStorage(): Promise<void>;
-export declare function detectStorageLoss(stored: string | null): string | null;
-export declare function nextGeneration(stored: string | null): string;
+export type RuntimeShell = {
+    persistentStorage: boolean;
+    generation: string | null;
+    keepGeneration(value: string): void | Promise<void>;
+    dropGeneration(): void | Promise<void>;
+};
+export declare function detectStorageLoss(stored: string | null, reported: string | null): string | null;
+export declare function nextGeneration(stored: string | null, reported: string | null): string;
 //# sourceMappingURL=durability.d.ts.map

package/dist/durability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["../src/durability.ts"],"names":[],"mappings":"AAiCA,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,IAAI,CAAC,CAG9D;AAoBD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAItE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAS5D"}
+{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["../src/durability.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,cAAc,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxC,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAG/F;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAGrF"}