narraeon 0.8.0 → 0.8.1

package/dist/node/runtime/setting/SettingImprovementSession.js

@@ -1,4 +1,8 @@
+import { completedAuthoringEdit, planAuthoringEdit, revertAuthoringChanges, } from "../authoring/AuthoringEditPlan.js";
+import { canRetryAuthoringDispatch, checkpointNextAuthoringDispatch, recoverAuthoringDispatch, } from "../authoring/AuthoringRetry.js";
 import { authoringRequestPreviews } from "../authoring/AuthoringRequestSnapshot.js";
+import { readGameplay } from "../../protocol/gameplay.js";
+import { isDeepStrictEqual } from "node:util";
 import { emptyAggregatedModelUsage } from "../../protocol/modelUsage.js";
 import { InvalidContentTreeError, } from "../content/ContentWorkspace.js";
 import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
@@ -10,12 +14,31 @@ import { summarizeStoredSettingImprovementSession, } from "./FileNativeSettingIm
 import { SettingAuthoringTransaction, settingImprovementRuntimeContract, settingImprovementToolDefinitions, authoringPreloadAuthorization, buildAuthoringPreload, contentPackageAuthoringSurface, } from "./SettingAuthoringTransaction.js";
 class RecoveryWriteConflictError extends Error {
 }
+const liveConversations = new Map();
+const releaseConversation = new FinalizationRegistry(({ scope, reference }) => {
+    if (liveConversations.get(scope) === reference)
+        liveConversations.delete(scope);
+});
 export class SettingImprovementRollbackError extends Error {
     constructor(message, options) {
         super(message, options);
         this.name = "SettingImprovementRollbackError";
     }
 }
+export class SettingMessageEditError extends Error {
+    reason;
+    paths;
+    constructor(reason, paths) {
+        super(reason === "conflict"
+            ? `Cannot revert changed files: ${paths.join(", ")}`
+            : reason === "invalid_tree"
+                ? `Reverting would make these files invalid: ${paths.join(", ")}`
+                : `Cannot attribute older file changes to this message: ${paths.join(", ")}`);
+        this.name = "SettingMessageEditError";
+        this.reason = reason;
+        this.paths = paths;
+    }
+}
 export class SettingImprovementSession {
     #store;
     #content;
@@ -25,7 +48,7 @@ export class SettingImprovementSession {
     #bindExistingModelHost;
     #bindPlayPreset;
     #preview;
-    #conversation = new ModelToolConversation();
+    #conversation;
     #changed;
     #mutationTail = Promise.resolve();
     constructor(input) {
@@ -35,6 +58,17 @@ export class SettingImprovementSession {
                     /* No observers attached. */
                 });
         this.#store = input.store;
+        let shared = liveConversations.get(input.store.sessionScope)?.deref();
+        if (shared === undefined) {
+            shared = new ModelToolConversation();
+            const reference = new WeakRef(shared);
+            liveConversations.set(input.store.sessionScope, reference);
+            releaseConversation.register(shared, {
+                scope: input.store.sessionScope,
+                reference,
+            });
+        }
+        this.#conversation = shared;
         this.#content = input.content;
         this.#compiler = input.compiler;
         this.#locale = input.locale;
@@ -123,7 +157,13 @@ export class SettingImprovementSession {
             const stored = await this.#store.read(sessionId);
             assertPackage(stored, packageId);
             await this.#recoverIfNeeded(stored);
-            await this.#store.deleteSession(packageId, sessionId);
+            const lease = await this.#content.beginCurrentTreeContentPackageOperation(packageId);
+            try {
+                await this.#store.deleteSession(packageId, sessionId);
+            }
+            finally {
+                lease.release();
+            }
         });
         return this.overview(packageId);
     }
@@ -186,11 +226,12 @@ export class SettingImprovementSession {
                 session = await this.#store.read(input.continuation.sessionId);
                 assertPackage(session, input.packageId);
             }
-            return this.#startRequest(session, requestId, async (next) => {
+            return this.#startRequest(session, requestId, async (next, lease) => {
                 if (next.runStatus === "paused")
                     throw new Error("Resume the paused authoring request before sending another message");
-                const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.packageId, next.modelBinding);
-                next.schemaVersion = 3;
+                const { playPreset, bootstrap, preload } = await this.#compilePackage(lease.package, next.modelBinding);
+                if (next.schemaVersion !== 5)
+                    next.schemaVersion = 4;
                 next.requests ??= [];
                 next.requests.push({
                     requestId,
@@ -200,20 +241,136 @@ export class SettingImprovementSession {
                     preload: structuredClone(preload.record),
                 });
                 next.authorization = authoringPreloadAuthorization(next.authorization, preload.record);
+                delete next.retryDispatch;
                 appendAuthoringUserMessage(next, message, requestId);
+                checkpointNextAuthoringDispatch(next, "dispatching");
                 if (next.modelBinding.provider === "google_interactions")
                     next.googleOutcomeUnknown = false;
             });
         });
         return prepared.run ?? this.#view(prepared.session);
     }
+    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 () => {
+            let session = await this.#store.read(input.sessionId);
+            assertPackage(session, input.packageId);
+            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 setting-improvement 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.");
+            const host = await this.#bindExistingModelHost(session.modelBinding);
+            if (!equalModelHostBinding(session.modelBinding, host.binding()))
+                throw new Error("No saved model connection matches this setting-improvement conversation");
+            const { itemIndex, tail, next } = planAuthoringEdit(session, edit);
+            const lease = await this.#content.beginCurrentTreeContentPackageOperation(input.packageId);
+            try {
+                if (!isDeepStrictEqual(await this.#store.read(session.sessionId), session))
+                    throw new Error("The authoring conversation changed; reload it before editing");
+                if (input.filePolicy === "revert" &&
+                    session.legacyDraft !== null &&
+                    (session.legacyDraft.outcome === "applied" ||
+                        session.legacyDraft.outcome === "apply_outcome_unknown") &&
+                    session.legacyDraft.changes.length > 0 &&
+                    !afterLegacyBoundary(session, itemIndex))
+                    throw new SettingMessageEditError("unattributed", [
+                        ...new Set(session.legacyDraft.changes.map(({ path }) => path)),
+                    ].sort());
+                const beforeFiles = lease.package.files;
+                const reverted = input.filePolicy === "revert"
+                    ? revertAuthoringChanges(beforeFiles, tail)
+                    : { files: beforeFiles, conflicts: [] };
+                if (reverted.conflicts.length > 0)
+                    throw new SettingMessageEditError("conflict", reverted.conflicts);
+                const afterFiles = reverted.files;
+                this.#content.validateCurrentTreeContentPackage(afterFiles);
+                if (input.filePolicy === "revert") {
+                    const existingIssues = new Set(this.#content
+                        .inspectCurrentTreeContentPackage(beforeFiles)
+                        .issues.map((issue) => JSON.stringify(issue)));
+                    const newIssues = this.#content
+                        .inspectCurrentTreeContentPackage(afterFiles)
+                        .issues.filter((issue) => !existingIssues.has(JSON.stringify(issue)));
+                    if (newIssues.length > 0)
+                        throw new SettingMessageEditError("invalid_tree", [...new Set(newIssues.map(({ path }) => path))].sort());
+                }
+                const { playPreset, bootstrap, preload } = await this.#compilePackage({
+                    ...lease.package,
+                    files: afterFiles,
+                    gameplay: readGameplay(afterFiles),
+                }, session.modelBinding);
+                next.schemaVersion = 5;
+                delete next.pendingEdit;
+                next.requests.push({
+                    requestId,
+                    modelItemStart: itemIndex,
+                    bootstrap,
+                    playPreset: structuredClone(playPreset),
+                    preload: structuredClone(preload.record),
+                });
+                next.authorization = authoringPreloadAuthorization(null, preload.record);
+                appendAuthoringUserMessage(next, message, requestId);
+                checkpointNextAuthoringDispatch(next, "dispatching");
+                if (next.modelBinding.provider === "google_interactions")
+                    next.googleOutcomeUnknown = false;
+                if (next.modelBinding.provider === "google_interactions" &&
+                    host.previewAuthoringRequest !== undefined)
+                    next.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(next, requestId));
+                session.schemaVersion = 5;
+                session.requests ??= [];
+                session.pendingEdit = {
+                    beforeFingerprint: contentTreeFingerprint(beforeFiles),
+                    afterFingerprint: contentTreeFingerprint(afterFiles),
+                    afterFiles: structuredClone(afterFiles),
+                    next,
+                };
+                await this.#store.preparePendingEdit(session);
+                this.#changed(input.packageId, true);
+                const committed = await this.#store.finishPendingEdit(session, lease);
+                this.#changed(input.packageId, true);
+                return {
+                    session: committed,
+                    run: this.#startRun(committed, host, requestId),
+                };
+            }
+            finally {
+                lease.release();
+            }
+        });
+        return prepared.run ?? this.#view(prepared.session);
+    }
     /** Continues a paused conversation with the frozen request it paused in. */
     async resume(input) {
         const requestId = requiredRequestId(input.requestId);
         const prepared = await this.#mutate(async () => {
             const session = await this.#store.read(input.sessionId);
             assertPackage(session, input.packageId);
-            return this.#startRequest(session, requestId, (next) => resumePausedAuthoringConversation(next));
+            return this.#startRequest(session, requestId, (next) => {
+                if (canRetryAuthoringDispatch(next)) {
+                    next.runStatus = "running";
+                    next.activeRequestId = next.requests?.at(-1)?.requestId ?? null;
+                    next.lastFailure = null;
+                    next.updatedAt = Date.now();
+                }
+                else
+                    resumePausedAuthoringConversation(next);
+            });
         });
         return prepared.run ?? this.#view(prepared.session);
     }
@@ -223,8 +380,11 @@ export class SettingImprovementSession {
             return { session, run: null };
         const running = this.#conversation.running(session.sessionId);
         if (running !== null) {
-            if (running.requestId !== requestId)
+            if (running.requestId !== requestId) {
+                if (session.googleOutcomeUnknown)
+                    throw new Error("The Google request outcome is unknown; start a fresh model context.");
                 throw new Error("Another message in this setting-improvement conversation is still running");
+            }
             return { session, run: running.promise };
         }
         if (session.googleOutcomeUnknown)
@@ -232,13 +392,23 @@ export class SettingImprovementSession {
         const host = await this.#bindExistingModelHost(session.modelBinding);
         if (!equalModelHostBinding(session.modelBinding, host.binding()))
             throw new Error("No saved model connection matches this setting-improvement conversation");
-        await prepare(session);
-        if (session.modelBinding.provider === "google_interactions" &&
-            host.previewAuthoringRequest !== undefined &&
-            session.requests?.at(-1)?.requestId === requestId)
-            session.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(session, requestId));
-        await this.#store.save(session);
-        return { session, run: this.#startRun(session, host, requestId) };
+        const lease = await this.#content.beginCurrentTreeContentPackageOperation(session.packageId);
+        try {
+            if (!isDeepStrictEqual(await this.#store.read(session.sessionId), session))
+                throw new Error("The authoring conversation changed; reload it before continuing");
+            if (session.schemaVersion === 3)
+                session.schemaVersion = 4;
+            await prepare(session, lease);
+            if (session.modelBinding.provider === "google_interactions" &&
+                host.previewAuthoringRequest !== undefined &&
+                session.requests?.at(-1)?.requestId === requestId)
+                session.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(session, requestId));
+            await this.#store.save(session);
+            return { session, run: this.#startRun(session, host, requestId) };
+        }
+        finally {
+            lease.release();
+        }
     }
     async preview(packageId, sessionId) {
         const session = sessionId === undefined ? null : await this.#store.read(sessionId);
@@ -254,9 +424,12 @@ export class SettingImprovementSession {
         return bootstrap;
     }
     async #compileCurrent(packageId, modelBinding) {
+        const package_ = await this.#content.readCurrentTreeContentPackage(packageId);
+        return this.#compilePackage(package_, modelBinding);
+    }
+    async #compilePackage(package_, modelBinding) {
         const playPreset = await this.#bindPlayPreset();
         const locale = this.#locale();
-        const package_ = await this.#content.readCurrentTreeContentPackage(packageId);
         const preload = this.#preload(package_.files, modelBinding, playPreset, locale);
         const bootstrap = this.#compiler.compileSettingImprovement({
             contentPackageTitle: package_.title,
@@ -329,7 +502,8 @@ export class SettingImprovementSession {
         const now = Date.now();
         const sessionId = this.#store.createId();
         const session = {
-            schemaVersion: 2,
+            schemaVersion: 4,
+            requests: [],
             sessionId,
             packageId,
             contentPackageTitle: package_.title,
@@ -366,6 +540,7 @@ export class SettingImprovementSession {
             session,
             host,
             requestId,
+            exchangeRequestId: session.activeRequestId ?? requestId,
             save: (next) => this.#store.save(next),
             recordGoogleHop: (id, hop) => this.#store.recordGoogleHop(session.sessionId, id, hop),
             settleToolResponse: async (next, assistantItemIndex, toolCalls) => {
@@ -377,10 +552,11 @@ export class SettingImprovementSession {
                 cancelled: "The setting-improvement response was cancelled. Complete tool responses already published to the current tree were retained.",
                 interrupted: "The setting-improvement response was interrupted",
             },
+            retrySupported: session.schemaVersion === 4 || session.schemaVersion === 5,
         });
     }
     async #settleToolResponse(session, assistantItemIndex, calls, active) {
-        const lease = await this.#content.beginCurrentTreeContentPackageOperation(session.packageId);
+        const lease = await this.#content.beginCurrentTreeContentPackageOperation(session.packageId, { wait: true });
         try {
             const beforeFingerprint = contentTreeFingerprint(lease.package.files);
             session.pendingSettlement = {
@@ -420,6 +596,8 @@ export class SettingImprovementSession {
                 }
             }
             this.#finalizeSettlement(session, prepared);
+            if (session.schemaVersion === 4 || session.schemaVersion === 5)
+                checkpointNextAuthoringDispatch(session, "dispatching");
             session.updatedAt = Date.now();
             await this.#store.save(session);
             return { revision: afterFingerprint, transaction };
@@ -454,9 +632,43 @@ export class SettingImprovementSession {
     async #recoverIfNeeded(original) {
         if (this.#conversation.isRunning(original.sessionId))
             return original;
+        if (original.pendingEdit !== undefined) {
+            const lease = await this.#content.beginCurrentTreeContentPackageOperation(original.packageId);
+            lease.release();
+            const recovered = await this.#store.read(original.sessionId);
+            if (recovered.pendingEdit !== undefined)
+                throw new Error("The pending authoring edit has no valid package recovery marker");
+            return this.#recoverIfNeeded(recovered);
+        }
         let expected = original;
         const session = structuredClone(original);
         const pendingAssistant = lastPendingAssistant(session);
+        if (session.runStatus === "running" &&
+            session.pendingSettlement === null &&
+            pendingAssistant === null) {
+            const lease = await this.#content.beginCurrentTreeContentPackageOperation(session.packageId);
+            let latest;
+            try {
+                latest = await this.#store.read(session.sessionId);
+                if (this.#conversation.isRunning(session.sessionId))
+                    return latest;
+                if (isDeepStrictEqual(latest, original)) {
+                    if (session.modelBinding.provider === "google_interactions" &&
+                        session.googleOutcomeUnknown !== false)
+                        session.googleOutcomeUnknown = true;
+                    markInterruptedAfterRestart(session);
+                    recoverAuthoringDispatch(session);
+                    session.updatedAt = Date.now();
+                    if (await this.#store.saveIfUnchanged(original, session))
+                        return session;
+                    latest = await this.#store.read(session.sessionId);
+                }
+            }
+            finally {
+                lease.release();
+            }
+            return this.#recoverIfNeeded(latest);
+        }
         if (session.pendingSettlement === null && pendingAssistant !== null) {
             this.#finalizeUnconfirmedToolResponse(session, pendingAssistant.itemIndex, "Runtime found a complete tool response without the persisted current-tree revision that authorized it. The calls were not replayed against a newer tree; read the current tree again before editing.");
             markInterruptedAfterRestart(session);
@@ -475,6 +687,7 @@ export class SettingImprovementSession {
                     let fingerprint = contentTreeFingerprint(lease.package.files);
                     const pending = session.pendingSettlement;
                     let prepared = pending.phase === "publication_prepared" ? pending : null;
+                    let settled = false;
                     if (fingerprint === pending.beforeFingerprint) {
                         const assistant = assistantAt(session, pending.assistantItemIndex);
                         const transaction = this.#openTransaction(session, lease.package.files, fingerprint);
@@ -504,11 +717,20 @@ export class SettingImprovementSession {
                     }
                     else if (fingerprint === prepared.afterFingerprint) {
                         this.#finalizeSettlement(session, prepared);
+                        settled = true;
                     }
                     else {
                         this.#finalizeUnconfirmedToolResponse(session, prepared.assistantItemIndex, "The content package no longer matches either the original or prepared revision for this tool response. No claimed change is being treated as authoritative; read the current tree again before editing.");
                     }
                     markInterruptedAfterRestart(session);
+                    const request = session.requests?.at(-1);
+                    if (settled &&
+                        request !== undefined &&
+                        session.modelBinding.provider !== "google_interactions") {
+                        if (session.schemaVersion !== 5)
+                            session.schemaVersion = 4;
+                        checkpointNextAuthoringDispatch(session, "retryable");
+                    }
                     session.updatedAt = Date.now();
                     if (!(await this.#store.saveIfUnchanged(expected, session)))
                         throw new RecoveryWriteConflictError();
@@ -538,13 +760,6 @@ export class SettingImprovementSession {
                 "The Google request outcome is unknown; start a fresh model context.";
             session.updatedAt = Date.now();
         }
-        else if (session.runStatus === "running") {
-            if (session.modelBinding.provider === "google_interactions" &&
-                session.googleOutcomeUnknown !== false)
-                session.googleOutcomeUnknown = true;
-            markInterruptedAfterRestart(session);
-            session.updatedAt = Date.now();
-        }
         else {
             return session;
         }
@@ -601,6 +816,7 @@ export class SettingImprovementSession {
                 updatedAt: session.updatedAt,
             },
             lastFailure: session.lastFailure,
+            canRetry: canRetryAuthoringDispatch(session),
         };
     }
     async #mutate(operation) {
@@ -764,6 +980,13 @@ function treeMatchesChangeBefore(files, change) {
         current.encoding === undefined &&
         current.contents === expected);
 }
+function afterLegacyBoundary(session, itemIndex) {
+    const first = session.requests?.[0];
+    return (first !== undefined &&
+        itemIndex >= first.modelItemStart &&
+        (first.modelItemStart > 0 ||
+            session.editReceipts?.some((receipt) => receipt.requestId === first.requestId) === true));
+}
 function restoreChangeBefore(files, change) {
     const restored = new Map(files.map((file) => [file.path, structuredClone(file)]));
     if (change.before === null)

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

@@ -4,7 +4,7 @@ import { isPackageFollowupControlPath } from "../content/PackageFollowups.js";
 import { validAuthoringRequests, } from "../authoring/AuthoringRequestSnapshot.js";
 import { createHash, randomUUID } from "node:crypto";
 import { readGoogleHops, writeGoogleHop } from "../model/GoogleHopJournal.js";
-import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { link, mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { gameplayPath } from "../../protocol/gameplay.js";
 import { validGoogleInteractionsSteps } from "../model/ProviderExchangeState.js";
@@ -43,6 +43,9 @@ export class FileNativeWorldRevisionStore {
         this.#epochsRoot = join(root, "epochs");
         this.#sessionsRoot = join(root, "sessions");
     }
+    get sessionScope() {
+        return this.#sessionsRoot;
+    }
     createEpochId() {
         return `revision-${randomUUID()}`;
     }
@@ -114,9 +117,90 @@ export class FileNativeWorldRevisionStore {
     saveSession(session) {
         return this.#mutate(async () => {
             validateSession(session);
-            await publishJson(this.#sessionPath(session.sessionId), session);
+            const path = this.#sessionPath(session.sessionId);
+            {
+                const source = await readFile(path).catch((error) => {
+                    if (isNodeError(error) && error.code === "ENOENT")
+                        return null;
+                    throw error;
+                });
+                if (source !== null) {
+                    const old = validateSession(JSON.parse(source.toString("utf8")));
+                    if (old.schemaVersion === 3 && session.schemaVersion !== 3)
+                        throw new Error("Cannot downgrade a migrated world-revision session");
+                    if (old.schemaVersion !== 3) {
+                        const backup = join(this.#sessionsRoot, ".legacy", `${session.sessionId}.json`);
+                        await mkdir(dirname(backup), { recursive: true, mode: 0o700 });
+                        const temporary = `${backup}.${randomUUID()}.tmp`;
+                        try {
+                            const handle = await open(temporary, "wx", 0o600);
+                            try {
+                                await handle.writeFile(source);
+                            }
+                            finally {
+                                await handle.close();
+                            }
+                            try {
+                                await link(temporary, backup);
+                            }
+                            catch (error) {
+                                if (!isNodeError(error) || error.code !== "EEXIST")
+                                    throw error;
+                            }
+                            if (!(await readFile(backup)).equals(source))
+                                throw new Error("World-revision legacy source backup does not match the original bytes");
+                        }
+                        finally {
+                            await rm(temporary, { force: true });
+                        }
+                        session.schemaVersion = 3;
+                        validateSession(session);
+                    }
+                }
+            }
+            await publishJson(path, session);
         });
     }
+    async prepareEdit(input) {
+        validateEpoch(input.epoch);
+        validateSession(input.session);
+        if (input.epoch.worldId !== input.session.worldId ||
+            input.epoch.epochId !== input.session.epochId ||
+            !treeRevisionPattern.test(input.beforeRevision))
+            throw new Error("Invalid world-revision edit intent");
+        await publishJson(this.#editPath(input.epoch.epochId), input);
+    }
+    async readEdit(epochId) {
+        let value;
+        try {
+            value = JSON.parse(await readFile(this.#editPath(epochId), "utf8"));
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (!isRecord(value) ||
+            !hasExactKeys(value, ["beforeRevision", "epoch", "session"]) ||
+            typeof value.beforeRevision !== "string" ||
+            !treeRevisionPattern.test(value.beforeRevision))
+            throw new Error("Invalid world-revision edit intent");
+        const epoch = validateEpoch(value.epoch);
+        const session = validateSession(value.session);
+        if (epoch.epochId !== epochId ||
+            epoch.worldId !== session.worldId ||
+            epoch.epochId !== session.epochId ||
+            epoch.lifecycle !== "active")
+            throw new Error("Invalid world-revision edit identity");
+        return { beforeRevision: value.beforeRevision, epoch, session };
+    }
+    async removeEdit(epochId) {
+        await rm(this.#editPath(epochId), { force: true });
+    }
+    #editPath(epochId) {
+        assertEpochId(epochId);
+        return join(this.#epochsRoot, `.edit-${epochId}.json`);
+    }
     async listSessions(worldId) {
         return this.#afterMutations(async () => {
             const entries = await readdir(this.#sessionsRoot, {
@@ -339,15 +423,51 @@ function validateSession(value) {
             "lastFailure",
             "authorization",
             "pendingSettlement",
-        ], ["requests", "googleOutcomeUnknown"]) ||
-        (value.schemaVersion !== 1 && value.schemaVersion !== 2) ||
+        ], [
+            "requests",
+            "googleOutcomeUnknown",
+            ...(value.schemaVersion === 3 ? ["retryDispatch", "editReceipts"] : []),
+        ]) ||
+        (value.schemaVersion !== 1 &&
+            value.schemaVersion !== 2 &&
+            value.schemaVersion !== 3) ||
+        (value.editReceipts !== undefined &&
+            !validEditReceipts(value.editReceipts)) ||
+        (value.retryDispatch !== undefined &&
+            (!isRecord(value.retryDispatch) ||
+                !hasExactKeys(value.retryDispatch, [
+                    "requestId",
+                    "exchange",
+                    "modelItemCount",
+                    "state",
+                ]) ||
+                !nonEmptyString(value.retryDispatch.requestId) ||
+                !count(value.retryDispatch.exchange) ||
+                !count(value.retryDispatch.modelItemCount) ||
+                !Array.isArray(value.requests) ||
+                !isRecord(value.requests.at(-1)) ||
+                value.requests.at(-1).requestId !==
+                    value.retryDispatch.requestId ||
+                (value.runStatus !== "running" && value.runStatus !== "interrupted") ||
+                (value.retryDispatch.state === "retryable" &&
+                    (!isRecord(value.modelBinding) ||
+                        value.modelBinding.provider === "google_interactions")) ||
+                value.pendingSettlement !== null ||
+                !count(value.exchange) ||
+                (value.retryDispatch.exchange !== value.exchange &&
+                    value.retryDispatch.exchange !== value.exchange + 1) ||
+                value.retryDispatch.modelItemCount !==
+                    (Array.isArray(value.modelItems) ? value.modelItems.length : -1) ||
+                !["dispatching", "retryable", "blocked"].includes(String(value.retryDispatch.state)))) ||
         (value.schemaVersion === 1
             ? value.requests !== undefined
-            : !validAuthoringRequests(value.requests, validPromptCompilation, {
-                modelItems: value.modelItems,
-                activeRequestId: value.activeRequestId,
-                completedRequestIds: value.completedRequestIds,
-            })) ||
+            : value.schemaVersion === 3 && value.requests === undefined
+                ? value.retryDispatch !== undefined
+                : !validAuthoringRequests(value.requests, validPromptCompilation, {
+                    modelItems: value.modelItems,
+                    activeRequestId: value.activeRequestId,
+                    completedRequestIds: value.completedRequestIds,
+                })) ||
         typeof value.sessionId !== "string" ||
         !nonEmptyString(value.worldId) ||
         typeof value.worldTitle !== "string" ||
@@ -389,6 +509,31 @@ function validateSession(value) {
     assertEpochId(value.epochId);
     return structuredClone(value);
 }
+function validEditReceipts(value) {
+    if (!Array.isArray(value))
+        return false;
+    const ids = new Set();
+    return value.every((entry) => {
+        if (!isRecord(entry) ||
+            !hasExactKeys(entry, [
+                "requestId",
+                "messageId",
+                "message",
+                "filePolicy",
+            ]) ||
+            typeof entry.requestId !== "string" ||
+            !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(entry.requestId) ||
+            ids.has(entry.requestId) ||
+            !nonEmptyString(entry.messageId) ||
+            typeof entry.message !== "string" ||
+            entry.message.trim().length === 0 ||
+            entry.message.length > 64 * 1024 ||
+            (entry.filePolicy !== "keep" && entry.filePolicy !== "revert"))
+            return false;
+        ids.add(entry.requestId);
+        return true;
+    });
+}
 function validFiles(value) {
     if (!Array.isArray(value))
         return false;