narraeon 0.7.10 → 0.8.1

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

@@ -3,9 +3,12 @@ import { upgradeLegacyEpochs } from "./LegacyWorldRevisionEpochUpgrade.js";
 import { isPackageFollowupControlPath } from "../content/PackageFollowups.js";
 import { validAuthoringRequests, } from "../authoring/AuthoringRequestSnapshot.js";
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, open, readFile, readdir, rename, rm } from "node:fs/promises";
+import { readGoogleHops, writeGoogleHop } from "../model/GoogleHopJournal.js";
+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";
+import { hasDamagedGoogleSteps, withoutDamagedGoogleSteps, } from "../authoring/DamagedGoogleContinuation.js";
 import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
 import { isPlayPresetBinding, } from "../play/FileNativePlayPresetStore.js";
 const uuidV4Pattern = "[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}";
@@ -40,12 +43,19 @@ export class FileNativeWorldRevisionStore {
         this.#epochsRoot = join(root, "epochs");
         this.#sessionsRoot = join(root, "sessions");
     }
+    get sessionScope() {
+        return this.#sessionsRoot;
+    }
     createEpochId() {
         return `revision-${randomUUID()}`;
     }
     createSessionId() {
         return `world-session-${randomUUID()}`;
     }
+    recordGoogleHop(sessionId, requestId, hop) {
+        assertSessionId(sessionId);
+        return writeGoogleHop(join(this.#sessionsRoot, ".google-hops", sessionId), requestId, hop, () => stat(this.#sessionPath(sessionId)).then(() => true, () => false));
+    }
     createChangeSetId() {
         return `change-set:${randomUUID()}`;
     }
@@ -89,14 +99,108 @@ export class FileNativeWorldRevisionStore {
         });
     }
     readSession(sessionId) {
-        return this.#afterMutations(() => this.#readSession(sessionId));
+        return this.#afterMutations(async () => {
+            try {
+                const session = await this.#readSession(sessionId);
+                if (hasDamagedGoogleSteps(session) &&
+                    (await this.#damagedSession(sessionId)))
+                    throw new Error("The historical conversation has damaged Google continuation; start a fresh model context");
+                return session;
+            }
+            catch (error) {
+                if (await this.#damagedSession(sessionId))
+                    throw new Error("The historical conversation has damaged Google continuation; start a fresh model context", { cause: error });
+                throw error;
+            }
+        });
     }
     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, {
@@ -110,7 +214,19 @@ export class FileNativeWorldRevisionStore {
             for (const entry of entries) {
                 if (!entry.isFile() || !sessionName.test(entry.name))
                     continue;
-                const session = await this.#readSession(entry.name.slice(0, -5));
+                const sessionId = entry.name.slice(0, -5);
+                let session;
+                try {
+                    session = await this.#readSession(sessionId);
+                    if (hasDamagedGoogleSteps(session))
+                        session = (await this.#damagedSession(sessionId)) ?? session;
+                }
+                catch (error) {
+                    const damaged = await this.#damagedSession(sessionId);
+                    if (damaged === null)
+                        throw error;
+                    session = damaged;
+                }
                 if (session.worldId === worldId)
                     sessions.push(session);
             }
@@ -118,7 +234,10 @@ export class FileNativeWorldRevisionStore {
         });
     }
     async findByCreationRequest(worldId, requestId) {
-        return ((await this.listSessions(worldId)).find(({ creationRequestId }) => creationRequestId === requestId) ?? null);
+        const match = (await this.listSessions(worldId)).find(({ creationRequestId }) => creationRequestId === requestId);
+        if (match?.damagedContinuation)
+            throw new Error("The historical conversation has damaged Google continuation; start a fresh model context with a new request ID");
+        return match ?? null;
     }
     deleteSession(worldId, sessionId) {
         return this.#mutate(async () => {
@@ -126,6 +245,10 @@ export class FileNativeWorldRevisionStore {
             if (session.worldId !== worldId)
                 throw new Error("World-revision conversation belongs to another world");
             await rm(this.#sessionPath(sessionId));
+            await rm(join(this.#sessionsRoot, ".google-hops", sessionId), {
+                recursive: true,
+                force: true,
+            });
         });
     }
     async #readEpoch(epochId) {
@@ -155,8 +278,34 @@ export class FileNativeWorldRevisionStore {
         const session = validateSession(value);
         if (session.sessionId !== sessionId)
             throw new Error("World-revision conversation identity does not match its file");
+        for (const request of session.requests ?? [])
+            if (request.wireRequest !== undefined)
+                request.wireRequest = await readGoogleHops(join(this.#sessionsRoot, ".google-hops", sessionId), request.requestId, request.wireRequest);
         return session;
     }
+    async #damagedSession(sessionId) {
+        const raw = JSON.parse(await readFile(this.#sessionPath(sessionId), "utf8"));
+        const copy = withoutDamagedGoogleSteps(raw);
+        if (copy === null) {
+            if (hasDamagedGoogleSteps(raw))
+                throw new Error("Cannot safely identify the damaged historical conversation; settlement or identity is unverified");
+            return null;
+        }
+        const session = validateSession(copy);
+        if (session.sessionId !== sessionId ||
+            session.requests?.[0]?.requestId !== session.creationRequestId ||
+            !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/u.test(session.creationRequestId))
+            throw new Error("Cannot safely identify the damaged historical conversation; its creation identity is unverified");
+        const epoch = await this.#readEpoch(session.epochId);
+        if (epoch.worldId !== session.worldId)
+            throw new Error("Cannot safely identify the damaged historical conversation; its world is inconsistent");
+        return {
+            ...session,
+            damagedContinuation: true,
+            runStatus: "interrupted",
+            lastFailure: "Google continuation is damaged; start a fresh model context.",
+        };
+    }
     async #afterMutations(read) {
         await this.#mutationTail;
         return read();
@@ -274,15 +423,51 @@ function validateSession(value) {
             "lastFailure",
             "authorization",
             "pendingSettlement",
-        ], ["requests"]) ||
-        (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" ||
@@ -311,6 +496,10 @@ function validateSession(value) {
         !Array.isArray(value.completedRequestIds) ||
         !value.completedRequestIds.every((item) => typeof item === "string") ||
         (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
+        (value.googleOutcomeUnknown !== undefined &&
+            (typeof value.googleOutcomeUnknown !== "boolean" ||
+                !isRecord(value.modelBinding) ||
+                value.modelBinding.provider !== "google_interactions")) ||
         !validAuthorization(value.authorization) ||
         !validPendingSettlement(value.pendingSettlement) ||
         !validPendingForSession(value.pendingSettlement, value.epochId, value.runStatus) ||
@@ -320,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;
@@ -452,6 +666,9 @@ function validModelToolCall(value) {
 function validProviderState(value) {
     if (!isRecord(value))
         return false;
+    if (value.protocol === "google_interactions")
+        return (hasExactKeys(value, ["protocol", "steps"]) &&
+            validGoogleInteractionsSteps(value.steps));
     if (value.protocol === "chat_completions")
         return hasExactKeys(value, ["protocol", "assistantMessage"]);
     if (value.protocol === "openai_responses")
@@ -509,7 +726,8 @@ function validModelBinding(value) {
         ], ["cacheStrategy"]) &&
         (value.provider === "chat_completions" ||
             value.provider === "openai_responses" ||
-            value.provider === "anthropic_messages") &&
+            value.provider === "anthropic_messages" ||
+            value.provider === "google_interactions") &&
         typeof value.endpointFingerprint === "string" &&
         typeof value.modelId === "string" &&
         count(value.contextWindowTokens) &&
@@ -531,7 +749,10 @@ function validModelUsage(value) {
         "totalTokens",
     ];
     if (!isRecord(value) ||
-        !hasExactKeys(value, [...fields, "provenance"]) ||
+        !hasExactKeys(value, [...fields, "provenance"], ["providerRaw", "accounting"]) ||
+        (value.providerRaw !== undefined && !isRecord(value.providerRaw)) ||
+        (value.accounting !== undefined &&
+            value.accounting !== "google_interactions") ||
         !fields.every((field) => value[field] === null || count(value[field])) ||
         !isRecord(value.provenance) ||
         !hasExactKeys(value.provenance, fields))
@@ -594,7 +815,7 @@ function validPendingSettlement(value) {
 function validPendingForSession(pending, epochId, runStatus) {
     return (pending === null ||
         (isRecord(pending) &&
-            runStatus === "running" &&
+            (runStatus === "running" || runStatus === "interrupted") &&
             pending.epochId === epochId));
 }
 function validToolResult(value) {