narraeon 0.7.10 → 0.8.1

package/dist/node/runtime/authoring/ModelToolConversation.js

@@ -1,8 +1,29 @@
+import { prepareAuthoringDispatch, failAuthoringDispatch, } from "./AuthoringRetry.js";
 import { randomUUID } from "node:crypto";
 import { aggregateModelUsage, } from "../../protocol/modelUsage.js";
 import { ModelHostCancelledError } from "../model/ModelHost.js";
+import { withGoogleHop } from "../model/GoogleRequestPreview.js";
 const maximumExchangesPerMessage = 64;
 const maximumStreamTailCharacters = 240;
+export function authoringExchange(session, requestId, boundaries) {
+    const bootstrap = session.requests?.at(-1)?.bootstrap ?? session.bootstrap;
+    return {
+        bootstrap,
+        toolUniverse: bootstrap.toolUniverse,
+        allowedTools: bootstrap.toolUniverse.map(({ name }) => name),
+        toolStrategy: bootstrap.toolStrategy,
+        tools: bootstrap.tools,
+        appended: session.modelItems,
+        ...(boundaries === undefined
+            ? {}
+            : { worldRevisionBoundaries: boundaries }),
+        requestId,
+        operationId: session.sessionId,
+        requestAttempt: 1,
+        exchange: session.exchange + 1,
+        maxOutputTokens: session.modelBinding.maxOutputTokens,
+    };
+}
 /**
  * Deep Module for the shared authoring-conversation loop. Its Interface leaves
  * content-package and world-revision publication behind the settlement seam.
@@ -56,41 +77,51 @@ export class ModelToolConversation {
     }
     async #execute(input, live) {
         const { session } = input;
-        const bootstrap = session.requests?.at(-1)?.bootstrap ?? session.bootstrap;
+        let phase = "settling";
         try {
             for (let round = 0; round < maximumExchangesPerMessage; round += 1) {
-                session.exchange += 1;
+                let request = authoringExchange(session, input.exchangeRequestId ?? live.requestId, input.worldRevisionBoundaries);
+                if (input.retrySupported)
+                    request = prepareAuthoringDispatch(session, request);
+                session.exchange = Math.max(session.exchange, request.exchange ?? session.exchange + 1);
+                if (session.modelBinding.provider === "google_interactions")
+                    session.googleOutcomeUnknown = true;
                 live.streaming = emptyStreaming();
                 session.updatedAt = Date.now();
+                phase = "preparing";
                 await input.save(session);
                 input.changed?.(true);
-                const response = await input.host.exchange({
-                    bootstrap,
-                    toolUniverse: bootstrap.toolUniverse,
-                    allowedTools: bootstrap.toolUniverse.map(({ name }) => name),
-                    toolStrategy: bootstrap.toolStrategy,
-                    tools: bootstrap.tools,
-                    appended: session.modelItems,
-                    requestId: live.requestId,
-                    operationId: session.sessionId,
-                    requestAttempt: 1,
-                    exchange: session.exchange,
-                    maxOutputTokens: session.modelBinding.maxOutputTokens,
-                }, {
+                phase = "dispatched";
+                const response = await input.host.exchange(request, {
                     signal: live.controller.signal,
+                    onGoogleHop: (hop) => {
+                        const requestId = input.exchangeRequestId ?? live.requestId;
+                        const snapshot = session.requests?.findLast((entry) => entry.requestId === requestId);
+                        if (snapshot?.wireRequest === undefined)
+                            return;
+                        snapshot.wireRequest = withGoogleHop(snapshot.wireRequest, hop);
+                        return input.recordGoogleHop?.(requestId, hop);
+                    },
                     onDelta: (delta) => {
                         recordDelta(live, delta);
                         input.changed?.(false);
                     },
                 });
+                if (live.controller.signal.aborted)
+                    throw new ModelHostCancelledError("The authoring request was cancelled");
+                phase = "validating";
                 assertCompleteResponse(response);
                 const toolCalls = response.toolCalls ?? [];
                 assertUniqueToolCallIds(toolCalls);
                 const visibleText = response.text ?? "";
-                if (toolCalls.length === 0 && visibleText.trim().length === 0)
+                session.usage = aggregateModelUsage(session.usage, response.usage);
+                if (toolCalls.length === 0 && visibleText.trim().length === 0) {
+                    phase = "dispatched";
                     throw new Error(input.failure?.emptyResponse ??
                         "The model returned an empty tool-free authoring response");
-                session.usage = aggregateModelUsage(session.usage, response.usage);
+                }
+                delete session.retryDispatch;
+                phase = "settling";
                 session.modelItems.push({
                     kind: "assistant",
                     text: visibleText,
@@ -100,6 +131,8 @@ export class ModelToolConversation {
                     providerState: response.providerState,
                     toolCalls: structuredClone(toolCalls),
                 });
+                if (session.modelBinding.provider === "google_interactions")
+                    session.googleOutcomeUnknown = false;
                 session.updatedAt = Date.now();
                 if (toolCalls.length === 0) {
                     session.messages.push({
@@ -121,6 +154,7 @@ export class ModelToolConversation {
             }
             // The exchange budget only bounds a runaway loop. Every tool response is
             // already settled, so the conversation pauses and can resume unchanged.
+            delete session.retryDispatch;
             session.runStatus = "paused";
             session.activeRequestId = null;
             session.completedRequestIds = rememberRequest(session.completedRequestIds, live.requestId);
@@ -130,17 +164,20 @@ export class ModelToolConversation {
             return input.view(session);
         }
         catch (error) {
+            failAuthoringDispatch(session, error, phase);
             session.runStatus = "interrupted";
             session.activeRequestId = null;
             session.completedRequestIds = rememberRequest(session.completedRequestIds, live.requestId);
             session.lastFailure =
-                error instanceof ModelHostCancelledError
-                    ? (input.failure?.cancelled ??
-                        "The authoring response was cancelled. Complete tool responses already settled were retained.")
-                    : error instanceof Error
-                        ? error.message
-                        : (input.failure?.interrupted ??
-                            "The authoring response was interrupted");
+                session.googleOutcomeUnknown === true
+                    ? "The Google request outcome is unknown; start a fresh model context before sending again."
+                    : error instanceof ModelHostCancelledError
+                        ? (input.failure?.cancelled ??
+                            "The authoring response was cancelled. Complete tool responses already settled were retained.")
+                        : error instanceof Error
+                            ? error.message
+                            : (input.failure?.interrupted ??
+                                "The authoring response was interrupted");
             session.updatedAt = Date.now();
             await input.save(session);
             return input.view(session);
@@ -170,7 +207,11 @@ export function appendAuthoringUserMessage(session, message, requestId) {
 export function resumePausedAuthoringConversation(session) {
     if (session.runStatus !== "paused")
         throw new Error("Only a paused authoring conversation can be continued");
-    if (session.modelItems.at(-1)?.kind !== "tool")
+    const last = session.modelItems.at(-1);
+    if (last?.kind !== "tool" &&
+        !(session.modelBinding.provider === "google_interactions" &&
+            session.googleOutcomeUnknown === false &&
+            last?.kind === "user"))
         throw new Error("The paused authoring conversation does not end with settled tool results");
     session.runStatus = "running";
     session.activeRequestId = session.requests?.at(-1)?.requestId ?? null;

package/dist/node/runtime/content/ContentWorkspace.js

@@ -1,5 +1,6 @@
 import { isAbsolute, win32 } from "node:path";
 import { inflateRawSync } from "node:zlib";
+import { FileNativeSettingImprovementStore } from "../setting/FileNativeSettingImprovementStore.js";
 import { portableContentTreePathKey } from "../../protocol/contentTree.js";
 import { fictionGameplay, gameplayFile, parseGameplay, } from "../../protocol/gameplay.js";
 import { defaultAppLocale, } from "../../protocol/appPreferences.js";
@@ -36,6 +37,10 @@ export class ContentWorkspace {
             limits: this.#limits,
             ...options.currentTree,
         });
+        const recovery = new FileNativeSettingImprovementStore(dataRoot, {
+            content: this,
+        });
+        this.#currentTreeLibrary.setBeforeLease((id, lease) => recovery.recoverPendingEdits(id, lease));
     }
     createCurrentTreeContentPackage(gameplay = fictionGameplay) {
         const locale = this.#locale();
@@ -64,8 +69,8 @@ export class ContentWorkspace {
     readCurrentTreeContentPackage(localId) {
         return this.#currentTreeLibrary.readPackage(localId);
     }
-    beginCurrentTreeContentPackageOperation(localId) {
-        return this.#currentTreeLibrary.acquireOperationLease(localId);
+    beginCurrentTreeContentPackageOperation(localId, options = {}) {
+        return this.#currentTreeLibrary.acquireOperationLease(localId, options);
     }
     inspectCurrentTreeContentPackage(files) {
         return inspectContentPackageCurrentTree(files);
@@ -96,6 +101,9 @@ export class ContentWorkspace {
             }, options.signal === undefined ? {} : { signal: options.signal });
         });
     }
+    importSillyTavernContent(title, files) {
+        return this.#mutate(() => this.#currentTreeLibrary.importPackage({ title, files }));
+    }
     copyCurrentTreeContentPackage(localId, options = {}) {
         return this.#mutate(() => this.#currentTreeLibrary.copyPackage(localId, options.signal === undefined ? {} : { signal: options.signal }));
     }

package/dist/node/runtime/content/CurrentTreeContentLibrary.js

@@ -61,6 +61,10 @@ export class CurrentTreeContentLibrary {
     #beforeCurrentTreeReplace;
     #mutationTail = Promise.resolve();
     #legacyLocksRemoval;
+    #beforeLease;
+    setBeforeLease(hook) {
+        this.#beforeLease = hook;
+    }
     constructor(dataRoot, options = {}) {
         this.#legacyLocksRoot = join(dataRoot, "content", ".package-locks");
         this.#packagesRoot = join(dataRoot, "content", "packages");
@@ -162,9 +166,6 @@ export class CurrentTreeContentLibrary {
         }
     }
     async readPackage(localId) {
-        const snapshot = await this.#readPackageSnapshot(localId);
-        if (snapshot.metadata.schemaVersion === 2)
-            return snapshot.package;
         const lease = await this.acquireOperationLease(localId, { wait: true });
         try {
             await ensureStoredPackageTitle(this.#packageRoot(localId), localId, lease.package.title);
@@ -221,7 +222,7 @@ export class CurrentTreeContentLibrary {
                     localId,
                     title: normalizedTitle,
                 });
-                return packageSummary(await this.readPackage(localId));
+                return packageSummary({ ...lease.package, title: normalizedTitle });
             }
             finally {
                 lease.release();
@@ -283,19 +284,24 @@ export class CurrentTreeContentLibrary {
             releaseInProcessPackageLease(packageRoot);
         };
         try {
-            const package_ = (await this.#readPackageSnapshot(localId)).package;
-            return {
-                package: structuredClone(package_),
+            let package_ = (await this.#readPackageSnapshot(localId)).package;
+            const lease = {
+                get package() {
+                    return structuredClone(package_);
+                },
                 replace: async (files, options = {}) => {
                     if (released)
                         throw new CurrentTreeContentPackageBusyError();
                     options.signal?.throwIfAborted();
                     const normalized = normalizeCurrentContentTreeFiles(files, this.#limits);
                     assertGameplayModeUnchanged(package_.files, normalized);
-                    return this.#replaceNormalizedCurrentTree(localId, package_.title, normalized, options.signal);
+                    package_ = await this.#replaceNormalizedCurrentTree(localId, package_.title, normalized, options.signal);
+                    return structuredClone(package_);
                 },
                 release,
             };
+            await this.#beforeLease?.(localId, lease);
+            return lease;
         }
         catch (error) {
             release();