narraeon 0.8.0 → 0.8.1

package/dist/node/protocol/v1.js

@@ -73,6 +73,14 @@ const requiredFields = {
         message: "string",
         continuation: "object",
     },
+    "setting-improvement.message.edit": {
+        packageId: "string",
+        sessionId: "string",
+        requestId: "string",
+        messageId: "string",
+        message: "string",
+        filePolicy: "string",
+    },
     "setting-improvement.cancel": { sessionId: "string" },
     "setting-improvement.resume": {
         packageId: "string",
@@ -152,6 +160,14 @@ const requiredFields = {
         message: "string",
         continuation: "object",
     },
+    "world.revision.message.edit": {
+        worldId: "string",
+        sessionId: "string",
+        requestId: "string",
+        messageId: "string",
+        message: "string",
+        filePolicy: "string",
+    },
     "world.revision.cancel": { sessionId: "string" },
     "world.revision.resume": {
         worldId: "string",
@@ -251,6 +267,10 @@ function validateRequestFields(request) {
         if (!valid || (kind === "string" && value === "" && !allowsEmptyString))
             throw new V1ProtocolError("invalid_request", `${String(request.type)}.${field} is invalid`);
     }
+    if (request.type === "setting-improvement.message.edit" &&
+        request.filePolicy !== "keep" &&
+        request.filePolicy !== "revert")
+        throw new V1ProtocolError("invalid_request", "setting-improvement.message.edit.filePolicy is invalid");
     if (request.type === "world.story.export" &&
         request.format !== "markdown" &&
         request.format !== "text")
@@ -510,6 +530,7 @@ const requestTypes = new Set([
     "setting-improvement.session.delete",
     "setting-improvement.rollback",
     "setting-improvement.message",
+    "setting-improvement.message.edit",
     "setting-improvement.cancel",
     "setting-improvement.resume",
     "play.read",
@@ -551,6 +572,7 @@ const requestTypes = new Set([
     "world.revision.session.read",
     "world.revision.session.delete",
     "world.revision.message",
+    "world.revision.message.edit",
     "world.revision.cancel",
     "world.revision.resume",
     "world.revision.files.replace",

package/dist/node/runtime/V1Runtime.js

@@ -25,7 +25,7 @@ import { projectArtifactForFrontend, projectDebugArtifactForFrontend, } from "./
 import { projectPlayerViewPanels, } from "./extension/PlayerViewPanelProjector.js";
 import { FileNativePromptCompiler } from "./prompt/FileNativePromptCompiler.js";
 import { FileNativeSettingImprovementStore } from "./setting/FileNativeSettingImprovementStore.js";
-import { SettingImprovementRollbackError, SettingImprovementSession, } from "./setting/SettingImprovementSession.js";
+import { SettingImprovementRollbackError, SettingImprovementSession, SettingMessageEditError, } from "./setting/SettingImprovementSession.js";
 import { FileNativeWorldStore } from "./world/FileNativeWorldStore.js";
 import { WorldDocumentStore } from "./world/WorldDocumentStore.js";
 import { FileNativeAiFailureLog } from "./model/AiFailureLog.js";
@@ -33,7 +33,7 @@ import { FileNativeRuntimeErrorLog } from "./RuntimeErrorLog.js";
 import { ProtagonistTemplateStore } from "./config/ProtagonistTemplateStore.js";
 import { AppPreferencesStore } from "./config/AppPreferencesStore.js";
 import { FileNativeWorldRevisionStore } from "./world-revision/FileNativeWorldRevisionStore.js";
-import { WorldRevisionSession } from "./world-revision/WorldRevisionSession.js";
+import { WorldRevisionSession, WorldRevisionMessageEditError, } from "./world-revision/WorldRevisionSession.js";
 import { WorldRevisionWorkspace, WorldRevisionWorkspaceError, } from "./world-revision/WorldRevisionWorkspace.js";
 import { ConversationChanges } from "./ConversationChanges.js";
 // 先取得当前端点再按它读取的请求，在端点被回退丢弃时最多重做这么多次（#94）。
@@ -424,6 +424,22 @@ export class V1Runtime {
                 }
             case "setting-improvement.message":
                 return this.#settingImprovements.send(request);
+            case "setting-improvement.message.edit":
+                try {
+                    return await this.#settingImprovements.editMessage(request);
+                }
+                catch (error) {
+                    if (error instanceof SettingMessageEditError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                            details: {
+                                kind: "setting_message_edit",
+                                reason: error.reason,
+                                paths: error.paths,
+                            },
+                        });
+                    throw error;
+                }
             case "setting-improvement.cancel":
                 return this.#settingImprovements.cancel(request.sessionId);
             case "setting-improvement.resume":
@@ -708,6 +724,22 @@ export class V1Runtime {
                 return this.#worldRevisionCall(() => this.#worldRevisions.deleteSession(request.worldId, request.sessionId));
             case "world.revision.message":
                 return this.#worldRevisionCall(() => this.#worldRevisions.send(request));
+            case "world.revision.message.edit":
+                try {
+                    return await this.#worldRevisionCall(() => this.#worldRevisions.editMessage(request));
+                }
+                catch (error) {
+                    if (error instanceof WorldRevisionMessageEditError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                            details: {
+                                kind: "world_revision_message_edit",
+                                reason: error.reason,
+                                paths: error.paths,
+                            },
+                        });
+                    throw error;
+                }
             case "world.revision.cancel":
                 return this.#worldRevisionCall(() => this.#worldRevisions.cancel(request.sessionId));
             case "world.revision.resume":

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

@@ -0,0 +1,79 @@
+import { validAuthoringNativeContinuation } from "../model/FileNativeModelAdapters.js";
+/** Checks idempotency before a target claims its own publication lease. */
+export function completedAuthoringEdit(session, edit) {
+    const prior = session.editReceipts?.find(({ requestId }) => requestId === edit.requestId);
+    if (prior !== undefined &&
+        (prior.messageId !== edit.messageId ||
+            prior.message !== edit.message ||
+            prior.filePolicy !== edit.filePolicy))
+        throw new Error("This edit request ID was already used for different content");
+    if (!session.completedRequestIds.includes(edit.requestId))
+        return false;
+    if (prior === undefined)
+        throw new Error("This request ID was already used for another authoring operation");
+    return true;
+}
+/** Locates and validates the native prefix and prepares the replacement transcript. */
+export function planAuthoringEdit(session, edit) {
+    const messageIndex = session.messages.findIndex((entry) => entry.role === "user" && entry.id === edit.messageId);
+    if (messageIndex < 0)
+        throw new Error("The selected authoring message no longer exists");
+    const userIndex = session.messages
+        .slice(0, messageIndex)
+        .filter((entry) => entry.role === "user").length;
+    const itemIndex = session.modelItems
+        .map((item, index) => (item.kind === "user" ? index : -1))
+        .filter((index) => index >= 0)[userIndex];
+    if (itemIndex === undefined ||
+        session.modelItems[itemIndex]?.kind !== "user" ||
+        session.modelItems[itemIndex].text !== session.messages[messageIndex].text)
+        throw new Error("The selected authoring message cannot be matched to the native transcript");
+    const prefix = session.modelItems.slice(0, itemIndex);
+    if (!validAuthoringNativeContinuation(prefix, session.modelBinding.provider))
+        throw new Error("The native continuation before this message is damaged; start a fresh context");
+    const next = structuredClone(session);
+    next.editReceipts = [...(next.editReceipts ?? []), edit];
+    delete next.retryDispatch;
+    next.modelItems = prefix;
+    next.messages = next.messages.slice(0, messageIndex);
+    next.requests = (next.requests ?? []).filter((entry) => entry.modelItemStart < itemIndex);
+    return {
+        itemIndex,
+        tail: session.modelItems.slice(itemIndex),
+        next: { ...next, requests: next.requests },
+    };
+}
+/** Returns a candidate tree and conflicts; the target validates and publishes it. */
+export function revertAuthoringChanges(files, items) {
+    const result = new Map(files.map((file) => [file.path, structuredClone(file)]));
+    const conflicts = new Set();
+    const changes = items.flatMap((item) => item.kind === "tool" && !item.isError ? item.changes : []);
+    for (const change of changes.reverse()) {
+        if (conflicts.has(change.path))
+            continue;
+        const malformed = (change.kind === "create" &&
+            (change.before !== null || change.after === null)) ||
+            (change.kind === "delete" &&
+                (change.before === null || change.after !== null)) ||
+            (change.kind === "modify" &&
+                (change.before === null ||
+                    change.after === null ||
+                    change.before === change.after));
+        const current = result.get(change.path);
+        if (malformed ||
+            (change.after === null
+                ? current !== undefined
+                : current?.contents !== change.after || current.encoding !== undefined)) {
+            conflicts.add(change.path);
+            continue;
+        }
+        if (change.before === null)
+            result.delete(change.path);
+        else
+            result.set(change.path, { path: change.path, contents: change.before });
+    }
+    return {
+        files: [...result.values()].sort((a, b) => a.path.localeCompare(b.path)),
+        conflicts: [...conflicts].sort(),
+    };
+}

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

@@ -0,0 +1,59 @@
+import { validAuthoringNativeContinuation } from "../model/FileNativeModelAdapters.js";
+import { dispatchRequiresFreshContext } from "../model/DispatchFailure.js";
+export function prepareAuthoringDispatch(session, request) {
+    const retry = session.retryDispatch;
+    if (retry?.state === "retryable") {
+        session.retryDispatch = { ...retry, state: "dispatching" };
+        return { ...request, requestId: retry.requestId, exchange: retry.exchange };
+    }
+    session.retryDispatch = {
+        requestId: request.requestId,
+        exchange: request.exchange,
+        modelItemCount: session.modelItems.length,
+        state: "dispatching",
+    };
+    return request;
+}
+export function checkpointNextAuthoringDispatch(session, state) {
+    const request = session.requests?.at(-1);
+    if (session.modelBinding.provider !== "google_interactions" &&
+        request !== undefined)
+        session.retryDispatch = {
+            requestId: request.requestId,
+            exchange: session.exchange + 1,
+            modelItemCount: session.modelItems.length,
+            state,
+        };
+}
+export function failAuthoringDispatch(session, error, phase) {
+    const checkpoint = session.retryDispatch;
+    if (checkpoint === undefined)
+        return;
+    // Acceptance clears the previous checkpoint. During settlement only a
+    // completed tool receipt can create the next one, before its final save.
+    const settledNextRequest = phase === "settling" &&
+        session.pendingSettlement === null &&
+        checkpoint.state === "dispatching" &&
+        checkpoint.modelItemCount === session.modelItems.length;
+    checkpoint.state =
+        session.modelBinding.provider !== "google_interactions" &&
+            (phase === "preparing" || phase === "dispatched" || settledNextRequest) &&
+            !dispatchRequiresFreshContext(error, false)
+            ? "retryable"
+            : "blocked";
+}
+export function recoverAuthoringDispatch(session) {
+    if (session.retryDispatch?.state === "dispatching")
+        session.retryDispatch.state =
+            session.modelBinding.provider === "google_interactions"
+                ? "blocked"
+                : "retryable";
+}
+export function canRetryAuthoringDispatch(session) {
+    return (session.runStatus === "interrupted" &&
+        session.modelBinding.provider !== "google_interactions" &&
+        session.googleOutcomeUnknown !== true &&
+        session.pendingSettlement === null &&
+        session.retryDispatch?.state === "retryable" &&
+        validAuthoringNativeContinuation(session.modelItems, session.modelBinding.provider));
+}

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

@@ -1,3 +1,4 @@
+import { prepareAuthoringDispatch, failAuthoringDispatch, } from "./AuthoringRetry.js";
 import { randomUUID } from "node:crypto";
 import { aggregateModelUsage, } from "../../protocol/modelUsage.js";
 import { ModelHostCancelledError } from "../model/ModelHost.js";
@@ -76,38 +77,51 @@ export class ModelToolConversation {
     }
     async #execute(input, live) {
         const { session } = input;
+        let phase = "settling";
         try {
             for (let round = 0; round < maximumExchangesPerMessage; round += 1) {
-                const request = authoringExchange(session, live.requestId, input.worldRevisionBoundaries);
-                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);
+                phase = "dispatched";
                 const response = await input.host.exchange(request, {
                     signal: live.controller.signal,
                     onGoogleHop: (hop) => {
-                        const snapshot = session.requests?.findLast((entry) => entry.requestId === live.requestId);
+                        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?.(live.requestId, 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,
@@ -140,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);
@@ -149,6 +164,7 @@ 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);

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);

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();

package/dist/node/runtime/model/DispatchFailure.js

@@ -0,0 +1,8 @@
+import { ModelHostBindingMismatchError, ModelHostContinuationError, ModelHostOutcomeUnknownError, modelHostFailureRequiresFreshContext, } from "./ModelHost.js";
+/** Protocol facts only; each lifecycle decides which failures permit replay. */
+export function dispatchRequiresFreshContext(error, googleDispatched) {
+    return (error instanceof ModelHostBindingMismatchError ||
+        error instanceof ModelHostContinuationError ||
+        (googleDispatched && error instanceof ModelHostOutcomeUnknownError) ||
+        modelHostFailureRequiresFreshContext(error));
+}

package/dist/node/runtime/model/FileNativeModelAdapters.js

@@ -1652,6 +1652,23 @@ function providerText(content) {
     }
     return JSON.stringify(content) ?? "";
 }
+/** Uses the same native payload checks as the production request encoders. */
+export function validAuthoringNativeContinuation(items, provider) {
+    return items.every((item) => {
+        if (item.kind !== "assistant")
+            return true;
+        const state = item.providerState;
+        if (state?.protocol !== provider)
+            return false;
+        if (state.protocol === "chat_completions")
+            return validChatAssistantMessage(state.assistantMessage);
+        if (state.protocol === "openai_responses")
+            return validResponsesOutput(state.output);
+        if (state.protocol === "anthropic_messages")
+            return validAnthropicContent(state.content);
+        return validGoogleInteractionsContinuation(state.steps);
+    });
+}
 function validChatAssistantMessage(value) {
     if (!isRecord(value) || value.role !== "assistant")
         return false;

package/dist/node/runtime/play/FileNativePlayTimelineStore.js

@@ -749,6 +749,55 @@ export class FileNativePlayTimelineStore {
             indexValue.chainId !== chainId ||
             stateValue.chainId !== chainId)
             throw new Error("Play context durable identity is inconsistent");
+        // Older releases disallowed retry after a player cancellation. The tail
+        // cancellation and interrupted assistant prove this was a dispatch ending,
+        // not a settlement failure. Validate the frozen request before exposing it.
+        if (!indexValue.importedFromArchive &&
+            stateValue.status === "interrupted" &&
+            !stateValue.canRetry &&
+            stateValue.eventCount >= 2) {
+            try {
+                const [tail, previous] = await Promise.all([
+                    readJson(join(root, "events", numbered(stateValue.eventCount))),
+                    readJson(join(root, "events", numbered(stateValue.eventCount - 1))),
+                ]);
+                assertPlayEvent(tail);
+                assertPlayEvent(previous);
+                if (tail.kind === "cancellation" &&
+                    previous.kind === "assistant" &&
+                    previous.status === "interrupted") {
+                    const [base, continuation] = await Promise.all([
+                        readJson(join(root, "base.json")),
+                        readJson(join(root, "continuations", `${stateValue.continuationDigest}.json`)),
+                    ]);
+                    assertContextBase(base);
+                    assertContextContinuation(continuation);
+                    if (base.worldId === worldId &&
+                        base.chainId === chainId &&
+                        continuation.chainId === chainId &&
+                        continuation.lastRequestDigest !== null &&
+                        createHash("sha256")
+                            .update(JSON.stringify(continuation))
+                            .digest("hex") === stateValue.continuationDigest) {
+                        const request = await readJson(join(root, "requests", `${continuation.lastRequestDigest}.json`));
+                        const provider = request.modelConfig?.provider ?? base.modelBinding?.provider;
+                        if (provider !== undefined &&
+                            provider !== "google_interactions" &&
+                            Array.isArray(request.appended) &&
+                            // The legacy record carries no codec-validation receipt. Only
+                            // requests without native assistant fragments can be proven safe.
+                            request.appended.every((item) => item.kind !== "assistant") &&
+                            createHash("sha256")
+                                .update(JSON.stringify(request))
+                                .digest("hex") === continuation.lastRequestDigest)
+                            stateValue.canRetry = true;
+                    }
+                }
+            }
+            catch {
+                // Missing or damaged legacy evidence never grants retry or breaks metadata reads.
+            }
+        }
         // Old versions persisted a configuration preflight failure as a terminal
         // context failure. Recover only the disposition proven by its event prefix.
         // Archive contexts and genuine provider failures retain their restrictions.

package/dist/node/runtime/play/PlayAdvanceLifecycle.js

@@ -1,4 +1,5 @@
-import { ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, modelHostFailureRequiresFreshContext, } from "../model/ModelHost.js";
+import { dispatchRequiresFreshContext } from "../model/DispatchFailure.js";
+import { ModelHostCancelledError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
 import { classifyPlayFailure } from "./PlayFailure.js";
 const messages = {
     playerCommitted: "The player message is committed; the frozen model request is ready to continue.",
@@ -97,19 +98,21 @@ export class PlayAdvanceLifecycle {
 }
 /**
  * The ending of an exchange that raised an error before its response was
- * settled. Cancellation after dispatch is named explicitly here and is never
- * a retry, even though `ModelHostCancelledError` is also an outcome-unknown
- * error (ADR-0030).
+ * settled. Google dispatched outcomes remain unknown and cannot be replayed.
  */
-export function dispatchFailureEnding(error, streamingEventId) {
+export function dispatchFailureEnding(error, streamingEventId, googleDispatched = false) {
     const message = errorMessage(error, messages.dispatchInterrupted);
     if (error instanceof ModelHostCancelledError)
-        return { kind: "cancelled_after_dispatch", message, streamingEventId };
-    const requiresFreshContext = error instanceof ModelHostBindingMismatchError ||
-        error instanceof ModelHostContinuationError ||
-        error instanceof ModelHostOutcomeUnknownError ||
-        modelHostFailureRequiresFreshContext(error);
-    const canRetry = !requiresFreshContext && error instanceof ModelHostFailureError;
+        return {
+            kind: "cancelled_after_dispatch",
+            message,
+            canRetry: !googleDispatched,
+            streamingEventId,
+        };
+    const requiresFreshContext = dispatchRequiresFreshContext(error, googleDispatched);
+    const canRetry = !requiresFreshContext &&
+        (error instanceof ModelHostFailureError ||
+            error instanceof ModelHostOutcomeUnknownError);
     return {
         kind: "failed",
         message,
@@ -141,12 +144,13 @@ export function noContinuationEnding() {
     };
 }
 /** A settled response with neither text nor a complete tool call. */
-export function emptyResponseEnding() {
+export function emptyResponseEnding(canRetry = false, streamingEventId) {
     return {
         kind: "failed",
         message: messages.noOutput,
         failureKind: "other",
-        canRetry: false,
+        canRetry,
+        streamingEventId,
     };
 }
 /**
@@ -199,7 +203,7 @@ function applyEnding(session, ending) {
         case "cancelled_after_dispatch":
             interruptStreamingEvent(session, ending.streamingEventId);
             session.status = "interrupted";
-            session.canRetry = false;
+            session.canRetry = ending.canRetry;
             session.lastFailure = ending.message;
             delete session.lastFailureKind;
             session.events.push({

package/dist/node/runtime/play/PlayCallChain.js

@@ -1281,14 +1281,14 @@ export class PlayCallChain {
                 calls.some((call) => call.id === event.callId)))
                 throw new ModelHostOutcomeUnknownError("Google Interactions repeated a tool-call ID during the same send; its outcome cannot be safely settled. Use a fresh context.");
         }
-        const text = durable.text ?? existing.text;
+        const text = durable.text ?? "";
         const hasText = text.trim().length > 0;
         const responseKind = calls.length > 0 ? "tool_step" : hasText ? "narrative" : "empty";
         const narrative = responseKind === "narrative";
         const assistantEvent = {
             id: advance.eventId,
             kind: "assistant",
-            text,
+            text: responseKind === "empty" ? existing.text : text,
             status: "completed",
             responseKind,
             exchange: advance.exchange,
@@ -1306,6 +1306,15 @@ export class PlayCallChain {
                 : { stopReason: durable.stopReason }),
             continuation: durable.providerState === undefined ? "unavailable" : "available",
         };
+        // No response has been settled or added to the transcript. Non-Google
+        // providers may explicitly replay the frozen request without duplicating work.
+        if (responseKind === "empty" &&
+            (session.lastRequest?.modelConfig?.provider ??
+                session.modelBinding?.provider) !== "google_interactions") {
+            session.events = session.events.map((event) => event.id === advance.eventId ? assistantEvent : event);
+            await this.#advances.end(session, emptyResponseEnding(true, advance.eventId), advance);
+            return { kind: "terminal", status: "interrupted", narrative: false };
+        }
         const workingTools = new Map(session.completedToolMap);
         const prepared = [];
         const trailingEvents = [];
@@ -1615,7 +1624,7 @@ export class PlayCallChain {
                     },
                 });
                 if (signal.aborted)
-                    throw new ModelHostCancelledError("The player cancelled the dispatched model request; its response was not committed and cannot be replayed.");
+                    throw new ModelHostCancelledError("The player cancelled the dispatched model request; its response was not committed.");
                 this.#setInvocationAbortable(session.chainId, false);
                 if ((response.toolCalls?.length ?? 0) > 0)
                     this.#observeInvocation(session.chainId, "tool", {
@@ -1625,7 +1634,10 @@ export class PlayCallChain {
                     await this.#failureLog?.recordExchangeIfActive(response.diagnostics);
             }
             catch (error) {
-                await this.#advances.end(session, dispatchFailureEnding(error, event.id), advance, () => this.#notifySnapshot(observer, session));
+                await this.#advances.end(session, dispatchFailureEnding(signal.aborted && !(error instanceof ModelHostCancelledError)
+                    ? new ModelHostCancelledError("The player cancelled the dispatched model request; its response was not committed.")
+                    : error, event.id, (request.modelConfig?.provider ??
+                    session.modelBinding?.provider) === "google_interactions"), advance, () => this.#notifySnapshot(observer, session));
                 return projectView(session);
             }
             try {