narraeon 0.8.0 → 0.8.1

package/dist/node/runtime/world-revision/WorldRevisionSession.js

@@ -1,3 +1,5 @@
+import { completedAuthoringEdit, planAuthoringEdit, revertAuthoringChanges, } from "../authoring/AuthoringEditPlan.js";
+import { canRetryAuthoringDispatch, checkpointNextAuthoringDispatch, recoverAuthoringDispatch, } from "../authoring/AuthoringRetry.js";
 import { authoringRequestPreviews } from "../authoring/AuthoringRequestSnapshot.js";
 import { createHash } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
@@ -8,9 +10,28 @@ import { equalModelHostBinding } from "../model/ModelHost.js";
 import { settingImprovementPromptForBinding, } from "../play/FileNativePlayPresetStore.js";
 import { authoringPreloadAuthorization, buildAuthoringPreload, worldRevisionAuthoringSurface, } from "../setting/SettingAuthoringTransaction.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { WorldRevisionAuthoringTransaction, worldRevisionRuntimeContract, worldRevisionToolDefinitions, } from "./WorldRevisionAuthoringTransaction.js";
+import { WorldRevisionAuthoringTransaction, inspectWorldRevisionFiles, worldRevisionRuntimeContract, worldRevisionToolDefinitions, } from "./WorldRevisionAuthoringTransaction.js";
 import { WorldRevisionWorkspaceError } from "./WorldRevisionWorkspace.js";
 import { historyEntries } from "../history/HistoryTools.js";
+export class WorldRevisionMessageEditError extends Error {
+    reason;
+    paths;
+    constructor(reason, paths = []) {
+        super(reason === "sealed"
+            ? "Changes in a sealed revision cannot be reverted; keep current files to continue"
+            : reason === "conflict"
+                ? `Cannot revert changed files: ${paths.join(", ")}`
+                : `Reverting would make the revision invalid: ${paths.join(", ")}`);
+        this.name = "WorldRevisionMessageEditError";
+        this.reason = reason;
+        this.paths = paths;
+    }
+}
+const liveScopes = new Map();
+const releaseScope = new FinalizationRegistry(({ scope, reference }) => {
+    if (liveScopes.get(scope) === reference)
+        liveScopes.delete(scope);
+});
 /** Conversation orchestration over the shared locked revision worktree. */
 export class WorldRevisionSession {
     #store;
@@ -22,9 +43,9 @@ export class WorldRevisionSession {
     #bindExistingModelHost;
     #bindPlayPreset;
     #preview;
-    #conversation = new ModelToolConversation();
+    #live;
+    #conversation;
     #changed;
-    #mutationTail = Promise.resolve();
     constructor(input) {
         this.#changed =
             input.changed ??
@@ -32,6 +53,21 @@ export class WorldRevisionSession {
                     /* No observers attached. */
                 });
         this.#store = input.store;
+        let live = liveScopes.get(input.store.sessionScope)?.deref();
+        if (live === undefined) {
+            live = {
+                conversation: new ModelToolConversation(),
+                mutationTail: Promise.resolve(),
+            };
+            const reference = new WeakRef(live);
+            liveScopes.set(input.store.sessionScope, reference);
+            releaseScope.register(live, {
+                scope: input.store.sessionScope,
+                reference,
+            });
+        }
+        this.#live = live;
+        this.#conversation = live.conversation;
         this.#workspace = input.workspace;
         this.#worlds = input.worlds;
         this.#compiler = input.compiler;
@@ -56,9 +92,9 @@ export class WorldRevisionSession {
     }
     async overview(worldId) {
         return this.#mutate(async () => {
-            const activeEpoch = await this.#workspace.active(worldId);
-            const [sessions, sealedEpochs] = await Promise.all([
-                this.#recoverWorldSessions(worldId),
+            const sessions = await this.#recoverWorldSessions(worldId);
+            const [activeEpoch, sealedEpochs] = await Promise.all([
+                this.#workspace.active(worldId),
                 this.#workspace.sealed(worldId),
             ]);
             const latest = sessions.find((session) => !session.damagedContinuation) ?? null;
@@ -68,7 +104,9 @@ export class WorldRevisionSession {
                     ? null
                     : this.#workspace.view(shownEpoch, activeEpoch?.epochId === shownEpoch.epochId),
                 sealedEpochs,
-                latest: latest === null ? null : this.#view(latest),
+                latest: latest === null
+                    ? null
+                    : this.#view(latest, activeEpoch?.epochId ?? null),
                 history: sessions.map(historyItem),
             };
         });
@@ -90,6 +128,7 @@ export class WorldRevisionSession {
     }
     async status(worldId, sessionId) {
         return this.#mutate(async () => {
+            await this.#workspace.active(worldId);
             const sessions = await this.#store.listSessions(worldId);
             const selectedIndex = sessionId === undefined
                 ? sessions.length === 0
@@ -116,7 +155,8 @@ export class WorldRevisionSession {
         return this.#mutate(async () => {
             const session = await this.#store.readSession(sessionId);
             assertWorld(session, worldId);
-            return this.#view(await this.#recoverIfNeeded(session));
+            const recovered = await this.#recoverIfNeeded(session);
+            return this.#view(recovered, (await this.#workspace.active(worldId))?.epochId ?? null);
         });
     }
     async deleteSession(worldId, sessionId) {
@@ -211,7 +251,8 @@ export class WorldRevisionSession {
             if (!equalModelHostBinding(session.modelBinding, host.binding()))
                 throw new Error("No saved model connection matches this world-revision conversation");
             const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.worldId, session.modelBinding);
-            session.schemaVersion = 2;
+            session.schemaVersion = 3;
+            delete session.retryDispatch;
             session.requests ??= [];
             session.requests.push({
                 requestId,
@@ -225,6 +266,7 @@ export class WorldRevisionSession {
             if (preload !== null)
                 session.authorization = authoringPreloadAuthorization(session.authorization, preload.record);
             appendAuthoringUserMessage(session, message, requestId);
+            checkpointNextAuthoringDispatch(session, "dispatching");
             if (session.modelBinding.provider === "google_interactions")
                 session.googleOutcomeUnknown = false;
             const boundaries = host.binding().provider === "google_interactions"
@@ -239,7 +281,112 @@ export class WorldRevisionSession {
                 run: this.#startRun(session, host, requestId, boundaries),
             };
         });
-        return prepared.run ?? this.#view(prepared.session);
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
+    }
+    async editMessage(input) {
+        const message = requiredMessage(input.message);
+        const requestId = requiredRequestId(input.requestId);
+        if (input.filePolicy !== "keep" && input.filePolicy !== "revert")
+            throw new Error("Invalid file policy");
+        const prepared = await this.#mutate(async () => {
+            // Recover the epoch intent before reading the conversation it may replace.
+            let epoch = await this.#workspace.active(input.worldId);
+            let session = await this.#store.readSession(input.sessionId);
+            assertWorld(session, input.worldId);
+            session = await this.#recoverIfNeeded(session);
+            const edit = {
+                requestId,
+                messageId: input.messageId,
+                message,
+                filePolicy: input.filePolicy,
+            };
+            if (completedAuthoringEdit(session, edit))
+                return { session, run: null };
+            const running = this.#conversation.running(session.sessionId);
+            if (running !== null) {
+                if (running.requestId !== requestId)
+                    throw new Error("Another message in this world-revision conversation is still running");
+                return { session, run: running.promise };
+            }
+            if (session.googleOutcomeUnknown)
+                throw new Error("The Google request outcome is unknown; start a fresh model context.");
+            await this.#assertNoRunningConversation(input.worldId, session.sessionId);
+            const host = await this.#bindExistingModelHost(session.modelBinding);
+            if (!equalModelHostBinding(session.modelBinding, host.binding()))
+                throw new Error("No saved model connection matches this world-revision conversation");
+            const { tail, next } = planAuthoringEdit(session, edit);
+            if (input.filePolicy === "revert") {
+                const activeChangeIds = new Set(epoch?.changes.map(({ changeSetId }) => changeSetId) ?? []);
+                if (tail.some((item) => item.kind === "tool" &&
+                    !item.isError &&
+                    item.changes.length > 0 &&
+                    (item.changeSetId === null ||
+                        !activeChangeIds.has(item.changeSetId))))
+                    throw new WorldRevisionMessageEditError("sealed");
+            }
+            epoch ??= await this.#workspace.open(input.worldId);
+            const reverted = input.filePolicy === "revert"
+                ? revertAuthoringChanges(epoch.files, tail)
+                : { files: epoch.files, conflicts: [] };
+            if (reverted.conflicts.length > 0)
+                throw new WorldRevisionMessageEditError("conflict", reverted.conflicts);
+            const afterFiles = reverted.files;
+            if (input.filePolicy === "revert") {
+                const inspection = inspectWorldRevisionFiles(afterFiles, epoch.baseFiles);
+                if (inspection.status !== "usable")
+                    throw new WorldRevisionMessageEditError("invalid_tree", [...new Set(inspection.diagnostics.map(({ path }) => path))].sort());
+            }
+            const candidate = {
+                ...epoch,
+                files: afterFiles,
+                revision: contentTreeFingerprint(afterFiles),
+            };
+            const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.worldId, session.modelBinding, candidate);
+            next.schemaVersion = 3;
+            if (session.epochId !== epoch.epochId ||
+                tail.some((item) => item.kind === "prompt_delta" &&
+                    item.logicalMessages.some((entry) => entry.blocks.some((block) => block.source.startsWith("runtime:world-revision-epoch:")))))
+                retargetSession(next, epoch, this.#locale());
+            next.epochId = epoch.epochId;
+            next.requests.push({
+                requestId,
+                modelItemStart: next.modelItems.length,
+                bootstrap,
+                playPreset: structuredClone(playPreset),
+                ...(preload === null
+                    ? {}
+                    : { preload: structuredClone(preload.record) }),
+            });
+            next.authorization =
+                preload === null
+                    ? null
+                    : authoringPreloadAuthorization(null, preload.record);
+            appendAuthoringUserMessage(next, message, requestId);
+            checkpointNextAuthoringDispatch(next, "dispatching");
+            if (next.modelBinding.provider === "google_interactions")
+                next.googleOutcomeUnknown = false;
+            const boundaries = host.binding().provider === "google_interactions"
+                ? await this.#validatedEpochBoundaries(next)
+                : undefined;
+            if (boundaries !== undefined &&
+                host.previewAuthoringRequest !== undefined)
+                next.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(next, requestId, boundaries));
+            await this.#workspace.publishEdit({
+                worldId: input.worldId,
+                epochId: epoch.epochId,
+                expectedRevision: epoch.revision,
+                files: afterFiles,
+                session: next,
+            });
+            this.#changed(input.worldId, true);
+            return {
+                session: next,
+                run: this.#startRun(next, host, requestId, boundaries),
+            };
+        });
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
     }
     /** Continues a paused conversation within the revision it paused in. */
     async resume(input) {
@@ -263,7 +410,14 @@ export class WorldRevisionSession {
             const host = await this.#bindExistingModelHost(session.modelBinding);
             if (!equalModelHostBinding(session.modelBinding, host.binding()))
                 throw new Error("No saved model connection matches this world-revision conversation");
-            resumePausedAuthoringConversation(session);
+            if (canRetryAuthoringDispatch(session)) {
+                session.runStatus = "running";
+                session.activeRequestId = session.requests?.at(-1)?.requestId ?? null;
+                session.lastFailure = null;
+                session.updatedAt = Date.now();
+            }
+            else
+                resumePausedAuthoringConversation(session);
             const boundaries = host.binding().provider === "google_interactions"
                 ? await this.#validatedEpochBoundaries(session)
                 : undefined;
@@ -273,7 +427,8 @@ export class WorldRevisionSession {
                 run: this.#startRun(session, host, requestId, boundaries),
             };
         });
-        return prepared.run ?? this.#view(prepared.session);
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
     }
     async preview(worldId, sessionId) {
         const session = sessionId === undefined ? null : await this.#store.readSession(sessionId);
@@ -288,8 +443,8 @@ export class WorldRevisionSession {
         const { bootstrap } = await this.#compileCurrent(worldId, host.binding());
         return bootstrap;
     }
-    async #compileCurrent(worldId, modelBinding) {
-        const epoch = await this.#workspace.active(worldId);
+    async #compileCurrent(worldId, modelBinding, overrideEpoch) {
+        const epoch = overrideEpoch ?? (await this.#workspace.active(worldId));
         const worlds = await this.#worlds.listWorlds();
         const playPreset = await this.#bindPlayPreset();
         const locale = this.#locale();
@@ -386,7 +541,8 @@ export class WorldRevisionSession {
         });
         const now = Date.now();
         const session = {
-            schemaVersion: 1,
+            schemaVersion: 3,
+            requests: [],
             sessionId: this.#store.createSessionId(),
             worldId,
             worldTitle,
@@ -410,7 +566,6 @@ export class WorldRevisionSession {
             authorization: null,
             pendingSettlement: null,
         };
-        await this.#store.saveSession(session);
         return session;
     }
     #startRun(session, host, requestId, worldRevisionBoundaries) {
@@ -420,6 +575,7 @@ export class WorldRevisionSession {
             session,
             host,
             requestId,
+            exchangeRequestId: session.activeRequestId ?? requestId,
             ...(worldRevisionBoundaries === undefined
                 ? {}
                 : { worldRevisionBoundaries }),
@@ -429,6 +585,7 @@ export class WorldRevisionSession {
                 activeTransaction = await this.#settleToolResponse(next, assistantItemIndex, calls, activeTransaction);
             },
             view: (next) => this.#view(next),
+            retrySupported: session.schemaVersion === 3,
             failure: {
                 cancelled: "The world-revision response was cancelled. Settled worktree changes were retained.",
                 interrupted: "The world-revision response was interrupted",
@@ -510,6 +667,8 @@ export class WorldRevisionSession {
             toolResults,
         });
         finalizeSettlement(session, prepared);
+        if (session.schemaVersion === 3)
+            checkpointNextAuthoringDispatch(session, "dispatching");
         session.updatedAt = Date.now();
         await this.#store.saveSession(session);
         return { revision: afterRevision, transaction };
@@ -571,6 +730,8 @@ export class WorldRevisionSession {
             return session;
         if (this.#conversation.isRunning(session.sessionId))
             return session;
+        await this.#workspace.active(session.worldId);
+        session = await this.#store.readSession(session.sessionId);
         const lastItem = session.modelItems.at(-1);
         if (session.pendingSettlement === null &&
             session.modelBinding.provider === "google_interactions" &&
@@ -607,6 +768,7 @@ export class WorldRevisionSession {
             session.googleOutcomeUnknown !== false)
             session.googleOutcomeUnknown = true;
         const recoveringSettlement = session.pendingSettlement !== null;
+        let settlementPublished = false;
         if (session.pendingSettlement !== null) {
             if (session.modelBinding.provider === "google_interactions")
                 session.googleOutcomeUnknown = false;
@@ -614,20 +776,16 @@ export class WorldRevisionSession {
             if (pending.phase === "publication_prepared") {
                 const active = await this.#workspace.active(session.worldId);
                 if (active?.epochId === pending.epochId) {
-                    try {
-                        await this.#workspace.publishAi({
-                            worldId: session.worldId,
-                            epochId: pending.epochId,
-                            expectedRevision: pending.beforeRevision,
-                            afterRevision: pending.afterRevision,
-                            files: pending.afterFiles,
-                            toolResults: pending.toolResults,
-                        });
-                        finalizeSettlement(session, pending);
-                    }
-                    catch (error) {
-                        finalizeUnconfirmed(session, pending.assistantItemIndex, error);
-                    }
+                    await this.#workspace.publishAi({
+                        worldId: session.worldId,
+                        epochId: pending.epochId,
+                        expectedRevision: pending.beforeRevision,
+                        afterRevision: pending.afterRevision,
+                        files: pending.afterFiles,
+                        toolResults: pending.toolResults,
+                    });
+                    finalizeSettlement(session, pending);
+                    settlementPublished = true;
                 }
                 else
                     finalizeUnconfirmed(session, pending.assistantItemIndex, new Error("The revision epoch ended before tool publication recovered"));
@@ -638,6 +796,13 @@ export class WorldRevisionSession {
         if (session.runStatus !== "running" && !recoveringSettlement)
             return session;
         const requestId = session.activeRequestId;
+        if (settlementPublished &&
+            session.modelBinding.provider !== "google_interactions" &&
+            session.requests?.at(-1) !== undefined) {
+            session.schemaVersion = 3;
+            checkpointNextAuthoringDispatch(session, "retryable");
+        }
+        recoverAuthoringDispatch(session);
         session.runStatus =
             session.modelBinding.provider === "google_interactions" &&
                 session.googleOutcomeUnknown === false
@@ -671,7 +836,7 @@ export class WorldRevisionSession {
             this.#conversation.isRunning(sessionId)))
             throw new WorldRevisionWorkspaceError("Wait for or cancel the running AI response before changing the revision");
     }
-    #view(session) {
+    #view(session, activeEpochId = session.epochId) {
         const streaming = session.runStatus === "running"
             ? this.#conversation.streaming(session.sessionId)
             : null;
@@ -691,6 +856,7 @@ export class WorldRevisionSession {
                 updatedAt: session.updatedAt,
             },
             lastFailure: session.lastFailure,
+            canRetry: activeEpochId === session.epochId && canRetryAuthoringDispatch(session),
         };
     }
     #statusView(session) {
@@ -709,9 +875,9 @@ export class WorldRevisionSession {
         };
     }
     async #mutate(operation) {
-        const previous = this.#mutationTail;
+        const previous = this.#live.mutationTail;
         let release = () => undefined;
-        this.#mutationTail = new Promise((resolveMutation) => {
+        this.#live.mutationTail = new Promise((resolveMutation) => {
             release = resolveMutation;
         });
         await previous;

package/dist/node/runtime/world-revision/WorldRevisionWorkspace.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
 import { readDeclaredWorldClock } from "../prompt/WorldMaintenanceReport.js";
 import { WorldOperationClaimLostError } from "../world/WorldOperationCoordinator.js";
@@ -125,6 +126,47 @@ export class WorldRevisionWorkspace {
             return epoch;
         });
     }
+    async publishEdit(input) {
+        const handle = revisionHandle(input);
+        await this.#withMutableEpoch(handle, async (epoch) => {
+            assertExpectedRevision(epoch, input.expectedRevision);
+            const files = cloneFiles(input.files);
+            assertUsableWorldRevisionFiles(files, epoch.baseFiles);
+            const changes = fileDiff(epoch.files, files);
+            if (changes.length > 0)
+                epoch.changes.push({
+                    changeSetId: this.#store.createChangeSetId(),
+                    source: "rollback",
+                    createdAt: Date.now(),
+                    changes,
+                });
+            epoch.files = files;
+            epoch.revision = contentTreeFingerprint(files);
+            epoch.updatedAt = Date.now();
+            await this.#store.prepareEdit({
+                beforeRevision: input.expectedRevision,
+                epoch,
+                session: input.session,
+            });
+            await this.#finishEdit(handle);
+        });
+    }
+    async #finishEdit(handle) {
+        const pending = await this.#store.readEdit(handle.epochId);
+        if (pending === null)
+            return;
+        if (pending.epoch.worldId !== handle.worldId)
+            throw new WorldRevisionWorkspaceError("Pending edit belongs to another world");
+        const current = await this.#store.readEpoch(handle.epochId);
+        if (!isDeepStrictEqual(current, pending.epoch)) {
+            if (current.lifecycle !== "active" ||
+                current.revision !== pending.beforeRevision)
+                throw new WorldRevisionWorkspaceError("Pending world-revision edit conflicts with the worktree");
+            await this.#store.saveEpoch(pending.epoch);
+        }
+        await this.#store.saveSession(pending.session);
+        await this.#store.removeEdit(handle.epochId);
+    }
     async rollback(input) {
         const handle = revisionHandle(input);
         return this.#withMutableEpoch(handle, async (epoch) => {
@@ -227,6 +269,7 @@ export class WorldRevisionWorkspace {
         };
     }
     async #resumeLocked(handle) {
+        await this.#withRevisionOwnership(handle, () => Promise.resolve());
         let epoch = await this.#store.readEpochIfPresent(handle.epochId);
         if (epoch === null) {
             const binding = await this.#worlds.bindWorldRevision(handle);
@@ -336,7 +379,10 @@ export class WorldRevisionWorkspace {
     }
     async #withRevisionOwnership(handle, action) {
         try {
-            return await this.#worlds.operations.withWorldRevisionLock(handle, action);
+            return await this.#worlds.operations.withWorldRevisionLock(handle, async () => {
+                await this.#finishEdit(handle);
+                return action();
+            });
         }
         catch (error) {
             if (error instanceof WorldOperationClaimLostError)