narraeon 0.7.10 → 0.8.1

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

@@ -1,21 +1,44 @@
+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";
 import { equalModelHostBinding } from "../model/ModelHost.js";
 import { settingImprovementPromptForBinding, } from "../play/FileNativePlayPresetStore.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { appendAuthoringUserMessage, ModelToolConversation, rememberAuthoringRequest, resumePausedAuthoringConversation, } from "../authoring/ModelToolConversation.js";
+import { appendAuthoringUserMessage, authoringExchange, ModelToolConversation, rememberAuthoringRequest, resumePausedAuthoringConversation, } from "../authoring/ModelToolConversation.js";
 import { summarizeStoredSettingImprovementSession, } from "./FileNativeSettingImprovementStore.js";
 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;
@@ -62,7 +96,7 @@ export class SettingImprovementSession {
     async overview(packageId) {
         return this.#mutate(async () => {
             let summaries = await this.#store.listSummariesByPackage(packageId);
-            const latestSummary = summaries[0];
+            const latestSummary = summaries.find((summary) => !summary.damagedContinuation);
             const latest = latestSummary === undefined
                 ? null
                 : await this.#recoverIfNeeded(await this.#store.read(latestSummary.sessionId));
@@ -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,9 +226,12 @@ export class SettingImprovementSession {
                 session = await this.#store.read(input.continuation.sessionId);
                 assertPackage(session, input.packageId);
             }
-            return this.#startRequest(session, requestId, async (next) => {
-                const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.packageId, next.modelBinding);
-                next.schemaVersion = 3;
+            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.#compilePackage(lease.package, next.modelBinding);
+                if (next.schemaVersion !== 5)
+                    next.schemaVersion = 4;
                 next.requests ??= [];
                 next.requests.push({
                     requestId,
@@ -198,18 +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);
     }
@@ -219,16 +380,35 @@ 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)
+            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");
-        await prepare(session);
-        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);
@@ -244,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,
@@ -317,9 +500,11 @@ export class SettingImprovementSession {
             tools,
         });
         const now = Date.now();
+        const sessionId = this.#store.createId();
         const session = {
-            schemaVersion: 2,
-            sessionId: this.#store.createId(),
+            schemaVersion: 4,
+            requests: [],
+            sessionId,
             packageId,
             contentPackageTitle: package_.title,
             locale,
@@ -327,6 +512,9 @@ export class SettingImprovementSession {
             createdAt: now,
             updatedAt: now,
             creationRequestId,
+            ...(modelBinding.provider === "google_interactions"
+                ? { googleIdentity: { sessionId, packageId, creationRequestId } }
+                : {}),
             bootstrap,
             modelBinding,
             playPreset: structuredClone(playPreset),
@@ -352,7 +540,9 @@ 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) => {
                 activeTransaction = await this.#settleToolResponse(next, assistantItemIndex, toolCalls, activeTransaction);
             },
@@ -362,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 = {
@@ -405,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 };
@@ -439,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);
@@ -451,6 +678,8 @@ export class SettingImprovementSession {
             return this.#recoverIfNeeded(await this.#store.read(session.sessionId));
         }
         if (session.pendingSettlement !== null) {
+            if (session.modelBinding.provider === "google_interactions")
+                session.googleOutcomeUnknown = false;
             const lease = await this.#content.beginCurrentTreeContentPackageOperation(session.packageId);
             let retry = false;
             try {
@@ -458,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);
@@ -487,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();
@@ -510,8 +749,15 @@ export class SettingImprovementSession {
                 return this.#recoverIfNeeded(await this.#store.read(session.sessionId));
             return session;
         }
-        if (session.runStatus === "running") {
-            markInterruptedAfterRestart(session);
+        const lastItem = session.modelItems.at(-1);
+        const legacyUnknown = session.modelBinding.provider === "google_interactions" &&
+            session.runStatus === "interrupted" &&
+            session.googleOutcomeUnknown === undefined &&
+            (lastItem?.kind === "user" || lastItem?.kind === "tool");
+        if (legacyUnknown) {
+            session.googleOutcomeUnknown = true;
+            session.lastFailure =
+                "The Google request outcome is unknown; start a fresh model context.";
             session.updatedAt = Date.now();
         }
         else {
@@ -570,6 +816,7 @@ export class SettingImprovementSession {
                 updatedAt: session.updatedAt,
             },
             lastFailure: session.lastFailure,
+            canRetry: canRetryAuthoringDispatch(session),
         };
     }
     async #mutate(operation) {
@@ -606,12 +853,17 @@ function lastPendingAssistant(session) {
 }
 function markInterruptedAfterRestart(session) {
     const requestId = session.activeRequestId;
-    session.runStatus = "interrupted";
+    session.runStatus =
+        session.modelBinding.provider === "google_interactions" &&
+            session.googleOutcomeUnknown === false
+            ? "paused"
+            : "interrupted";
     session.activeRequestId = null;
     if (requestId !== null)
         session.completedRequestIds = rememberAuthoringRequest(session.completedRequestIds, requestId);
-    session.lastFailure =
-        "The previous model request stopped before its next complete response. Every settled current-tree change and complete tool result was retained; continue this conversation when ready.";
+    session.lastFailure = session.googleOutcomeUnknown
+        ? "The Google request outcome is unknown; start a fresh model context."
+        : "The previous model request stopped before its next complete response. Every settled current-tree change and complete tool result was retained; continue this conversation when ready.";
 }
 function requiredMessage(message) {
     if (message.trim().length === 0)
@@ -728,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)
@@ -750,6 +1009,11 @@ function diffForRollback(files, change) {
 function settingImprovementHistoryItem(summary) {
     return {
         sessionId: summary.sessionId,
+        ...(summary.damagedContinuation
+            ? {
+                unavailableReason: "Google continuation is damaged; start a fresh model context.",
+            }
+            : {}),
         runStatus: summary.runStatus,
         createdAt: summary.createdAt,
         updatedAt: summary.updatedAt,