narraeon 0.7.10 → 0.8.1

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.",
@@ -10,6 +11,7 @@ const messages = {
     serviceStoppedAfterHead: "The service stopped after the world was updated; use a fresh context.",
     serviceStoppedSavingPlayer: "The service stopped while saving the player message; use a fresh context.",
     serviceStoppedRetryable: "The service stopped while the model request was in progress; retry to call the model again.",
+    serviceStoppedUnknown: "The service stopped after the model request may have been dispatched; its outcome is unknown. Use a fresh context.",
     serviceStoppedNoRequest: "The service stopped before preparing a model request; use a fresh context.",
     dispatchInterrupted: "The model request was interrupted.",
 };
@@ -43,29 +45,52 @@ export class PlayAdvanceLifecycle {
         notify?.();
     }
     /**
-     * Ends an advance that a process exit cut off (ADR-0044). Nothing is
-     * replayed: the exchange is interrupted, and only the chain's own frozen
-     * request can be retried, and only while the world has not moved on.
+     * Recovers an advance cut off by a process exit. A persisted ending wins;
+     * otherwise Google requests that may have been dispatched cannot be replayed
+     * (ADR-0035), while other recovery follows ADR-0044.
      */
     async recoverAbandoned(session, advance, headMoved) {
+        // Endings are persisted before their marker is cleared. If the process
+        // stopped in that gap, keep the durable ending rather than inventing a
+        // new retry decision for an advance that already settled.
+        if (advance !== null &&
+            session.status !== "running" &&
+            !(advance.advanceKind === "player" && session.status === "ready") &&
+            !headMoved) {
+            await this.#ports.clearMarker(advance);
+            return;
+        }
         const playerPhase = advance?.advanceKind === "player";
         const streaming = playerPhase
             ? undefined
             : session.events.findLast((event) => event.kind === "assistant" &&
                 event.status === "streaming" &&
                 (advance === null || event.id === advance.eventId));
-        const canRetry = !headMoved && !playerPhase && session.lastRequest !== null;
+        const unknownGoogleDispatch = advance?.advanceKind === "response" &&
+            session.status === "running" &&
+            (session.lastRequest?.modelConfig?.provider ??
+                session.modelBinding?.provider) === "google_interactions";
+        const canRetry = !headMoved &&
+            !playerPhase &&
+            !unknownGoogleDispatch &&
+            session.lastRequest !== null;
         const message = headMoved
             ? messages.serviceStoppedAfterHead
             : playerPhase
                 ? messages.serviceStoppedSavingPlayer
-                : canRetry
-                    ? messages.serviceStoppedRetryable
-                    : messages.serviceStoppedNoRequest;
+                : unknownGoogleDispatch
+                    ? messages.serviceStoppedUnknown
+                    : canRetry
+                        ? messages.serviceStoppedRetryable
+                        : messages.serviceStoppedNoRequest;
         await this.end(session, {
             kind: "failed",
             message,
-            failureKind: canRetry ? "retryable" : "other",
+            failureKind: unknownGoogleDispatch
+                ? "outcome_unknown"
+                : canRetry
+                    ? "retryable"
+                    : "other",
             canRetry,
             streamingEventId: streaming?.id,
         }, advance);
@@ -73,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,
@@ -117,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,
     };
 }
 /**
@@ -175,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({
@@ -203,7 +231,7 @@ function interruptStreamingEvent(session, eventId) {
     if (eventId === undefined)
         return;
     const event = session.events.find(({ id }) => id === eventId);
-    if (event?.kind === "assistant")
+    if (event?.kind === "assistant" && event.status === "streaming")
         event.status = "interrupted";
 }
 function errorMessage(error, fallback) {

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

@@ -16,7 +16,8 @@ import { turnGuideWithTurnNote } from "../../shared/turn-guide.js";
 import { completedPlayerRounds, continuationNotice, playerInputAppend, toolStepNotice, turnGuideNotice, } from "./PlayContinuity.js";
 import { renderWriteSizeAdvice, readDeclaredWorldClock, } from "../prompt/WorldMaintenanceReport.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { equalModelHostBinding, ModelHostCancelledError, } from "../model/ModelHost.js";
+import { equalModelHostBinding, ModelHostCancelledError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
+import { validGoogleInteractionsContinuation } from "../model/ProviderExchangeState.js";
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { parsePlayPresetFiles, } from "./FileNativePlayPresetStore.js";
 import { runPlayFollowupRequests, } from "./PlayFollowupRequests.js";
@@ -234,6 +235,12 @@ export class PlayCallChain {
         const session = await this.#requireChain(input.worldId, input.chainId);
         await this.#assertCurrentHead(session);
         assertSessionModelHostBinding(session, input.modelHost);
+        if (session.status === "ready" &&
+            session.modelBinding?.provider === "google_interactions" &&
+            session.transcript.some((item) => item.kind === "assistant" &&
+                (item.providerState?.protocol !== "google_interactions" ||
+                    !validGoogleInteractionsContinuation(item.providerState.steps))))
+            throw new PlayCallChainError("The Google Interactions continuation is missing or corrupted; start a fresh context.");
         if (input.playerText.trim().length === 0) {
             if (session.status === "running")
                 throw new PlayCallChainError("A model request is still running.");
@@ -869,6 +876,10 @@ export class PlayCallChain {
                 updatedAt: Date.now(),
             };
         }
+        if (intent.continuation === "continue_context")
+            await this.#worlds.playTimeline
+                .copyRetainedEncodings(worldId, sourceContext.chainId, revised)
+                .catch(() => forgetFollowupPreviews(revised));
         await this.#worlds.playTimeline.persist(revised);
         if (intent.continuation === "fresh_context")
             await this.#worlds.completeArchiveFreshContext(worldId);
@@ -965,6 +976,9 @@ export class PlayCallChain {
                 parentHead: intent.restoresHead,
                 updatedAt: Date.now(),
             };
+            await this.#worlds.playTimeline
+                .copyRetainedEncodings(intent.worldId, sourceContext.chainId, prefix)
+                .catch(() => forgetFollowupPreviews(prefix));
             await this.#worlds.playTimeline.persistDetached(structuredClone(prefix));
             previousChainId = prefix.chainId;
         }
@@ -1254,14 +1268,27 @@ export class PlayCallChain {
         if (existing?.kind !== "assistant")
             throw new PlayCallChainError("The durable Provider result no longer matches its assistant event.");
         const calls = durable.toolCalls ?? [];
-        const text = durable.text ?? existing.text;
+        if ((session.lastRequest?.modelConfig?.provider ??
+            session.modelBinding?.provider) === "google_interactions" &&
+            calls.length > 0) {
+            const boundary = session.events.findLastIndex((event) => event.kind === "player" ||
+                (event.kind === "assistant" &&
+                    event.status === "completed" &&
+                    event.responseKind === "narrative"));
+            if (session.events
+                .slice(boundary + 1)
+                .some((event) => event.kind === "tool_call" &&
+                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 ?? "";
         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,
@@ -1279,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 = [];
@@ -1561,6 +1597,8 @@ export class PlayCallChain {
                 }
                 response = await modelHost.exchange(request, {
                     signal,
+                    diagnosticAttempt: attempt,
+                    onGoogleHop: (hop) => this.#worlds.playTimeline.recordGoogleHop(session.worldId, session.chainId, session.promptRuns?.at(-1)?.exchange ?? 1, hop),
                     onDelta: (delta) => {
                         this.#observeInvocation(session.chainId, delta.kind, {
                             ...(delta.kind === "reasoning"
@@ -1586,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", {
@@ -1596,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 {
@@ -1661,7 +1702,7 @@ export class PlayCallChain {
                             },
                         ],
                     });
-                await this.#advances.end(session, ending, advance, () => this.#notifySnapshot(observer, session));
+                await this.#advances.end(session, { ...ending, streamingEventId: event.id }, advance, () => this.#notifySnapshot(observer, session));
                 return projectView(session);
             }
         }
@@ -1691,6 +1732,13 @@ export class PlayCallChain {
             event.committedHead === session.parentHead);
         if (reply === undefined)
             throw new PlayCallChainError("Follow-up reply is not committed");
+        const run = session.promptRuns?.at(-1);
+        const runReplies = session.events.filter((event) => event.kind === "assistant" &&
+            event.responseKind === "narrative" &&
+            event.committedHead !== undefined &&
+            event.id >= (run?.firstEventId ?? 1));
+        // Without a new prompt run there is no distinct bounded encoding slot.
+        const previewExchange = runReplies.length === 1 ? (run?.exchange ?? 1) : undefined;
         const observeFollowupDelta = (delta) => {
             this.#observeInvocation(session.chainId, "followup", {
                 ...(delta.kind === "reasoning"
@@ -1715,6 +1763,14 @@ export class PlayCallChain {
                     ? {}
                     : { reasoning: outcome.reasoning }),
                 ...(outcome.usage === undefined ? {} : { usage: outcome.usage }),
+                ...(outcome.requestPreviewRecorded !== true ||
+                    outcome.requestPreviewStatus === undefined ||
+                    previewExchange === undefined
+                    ? {}
+                    : {
+                        requestPreviewExchange: previewExchange,
+                        requestPreviewStatus: outcome.requestPreviewStatus,
+                    }),
                 toolCalls: structuredClone(outcome.toolCalls),
                 ...(outcome.failure === undefined ? {} : { failure: outcome.failure }),
             });
@@ -1757,6 +1813,21 @@ export class PlayCallChain {
                     ? {}
                     : { failureLog: this.#failureLog }),
                 observer: {
+                    onGoogleHop: async (id, hop) => {
+                        if (previewExchange !== undefined)
+                            await this.#worlds.playTimeline.recordGoogleHop(session.worldId, session.chainId, previewExchange, hop, id);
+                    },
+                    onRequest: async (id, request) => {
+                        if (previewExchange === undefined)
+                            return false;
+                        // Only Google currently has a continuation-redacting encoder.
+                        const preview = modelHost.binding().provider === "google_interactions"
+                            ? modelHost.previewAuthoringRequest?.(request)
+                            : undefined;
+                        if (preview === undefined)
+                            return false;
+                        return this.#worlds.playTimeline.recordFollowupEncoding(session.worldId, session.chainId, previewExchange, id, preview);
+                    },
                     onProviderDispatch: () => {
                         this.#setInvocationAbortable(session.chainId, true);
                         this.#observeInvocation(session.chainId, "followup", {
@@ -1837,8 +1908,9 @@ export class PlayCallChain {
     }
     /**
      * An in-progress advance, or a session still marked running, means a model
-     * dispatch or settlement was cut off by a process exit. Nothing is replayed:
-     * the exchange is interrupted and the player retries (ADR-0044).
+     * dispatch or settlement was cut off by a process exit. Recovery preserves
+     * persisted endings and applies the protocol's retry boundary (ADR-0035,
+     * ADR-0044).
      */
     async #reconcileSessionAdvance(session, loaded) {
         const advance = loaded === undefined
@@ -2364,6 +2436,9 @@ function assertSessionModelHostBinding(session, modelHost) {
         throw new PlayCallChainError("This model context predates durable provider continuation bindings; start a fresh context.");
     if (session.modelBinding.provider !== modelHost.binding().provider)
         throw new PlayCallChainError("The selected model protocol differs from this context. Switch back to its original protocol to continue, or start a fresh context.", "model_protocol_mismatch");
+    if (session.modelBinding.provider === "google_interactions" &&
+        !equalModelHostBinding(session.modelBinding, modelHost.binding()))
+        throw new PlayCallChainError("The selected model connection does not match the frozen Google binding; start a fresh context.");
 }
 function validateIdentity(value, label) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/u.test(value))
@@ -2398,6 +2473,15 @@ function turnNoteField(turnNote) {
 function touch(session) {
     session.updatedAt = Date.now();
 }
+/** Failed diagnostic copies cannot attach unrelated encodings to retained events. */
+function forgetFollowupPreviews(session) {
+    for (const event of session.events) {
+        if (event.kind !== "followup")
+            continue;
+        delete event.requestPreviewExchange;
+        delete event.requestPreviewStatus;
+    }
+}
 function notifyAssistantDelta(observer, delta) {
     try {
         observer?.onAssistantDelta?.(structuredClone(delta));

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

@@ -49,6 +49,8 @@ export async function runPlayFollowupRequests(input) {
         }
         if (signalWasAborted(input.signal)) {
             failure ??= "The follow-up request was cancelled.";
+            outcomes.push(outcome);
+            input.observer?.onOutcome?.(outcome);
             break;
         }
         outcomes.push(outcome);
@@ -91,10 +93,9 @@ async function runOne(input, followup, prefix, requestSignal) {
     try {
         await input.artifacts.beginRequestAttempt(requestContext);
         requestSignal?.throwIfAborted();
-        input.observer?.onProviderDispatch?.();
         let response;
         try {
-            response = await input.modelHost.exchange({
+            const request = {
                 bootstrap: structuredClone(input.bootstrap),
                 tools: structuredClone(followup.tools),
                 toolUniverse: structuredClone(followup.tools),
@@ -114,8 +115,23 @@ async function runOne(input, followup, prefix, requestSignal) {
                 requestAttempt: 1,
                 exchange: 1,
                 maxOutputTokens: input.maxOutputTokens,
-            }, {
+            };
+            try {
+                outcome.requestPreviewRecorded =
+                    (await input.observer?.onRequest?.(followup.id, request)) ?? false;
+            }
+            catch {
+                // Diagnostic recording must not change the provider request.
+            }
+            requestSignal?.throwIfAborted();
+            outcome.requestPreviewStatus = "attempted";
+            input.observer?.onProviderDispatch?.();
+            response = await input.modelHost.exchange(request, {
                 ...(requestSignal === undefined ? {} : { signal: requestSignal }),
+                onGoogleHop: (evidence) => input.observer?.onGoogleHop?.(followup.id, evidence),
+                ...(input.controls !== undefined
+                    ? { retainLateExtensionResponse: true }
+                    : {}),
                 onDelta: (delta) => input.observer?.onProviderDelta?.(delta),
             });
             if (input.signal?.aborted === true)
@@ -124,6 +140,7 @@ async function runOne(input, followup, prefix, requestSignal) {
         finally {
             input.observer?.onProviderSettled?.();
         }
+        outcome.requestPreviewStatus = "completed";
         responseDiagnostics = response.diagnostics;
         if (response.diagnostics !== undefined)
             await input.failureLog?.recordExchangeIfActive(response.diagnostics);
@@ -182,6 +199,9 @@ async function runOne(input, followup, prefix, requestSignal) {
             });
     }
     catch (error) {
+        if (outcome.requestPreviewStatus !== undefined &&
+            error instanceof ModelHostCancelledError)
+            outcome.requestPreviewStatus = "cancelled";
         outcome.failure =
             error instanceof Error
                 ? error.message

package/dist/node/runtime/prompt/PromptCompilationCodec.js

@@ -315,7 +315,8 @@ function validPromptCache(value) {
 export function validProviderKind(value) {
     return (value === "chat_completions" ||
         value === "openai_responses" ||
-        value === "anthropic_messages");
+        value === "anthropic_messages" ||
+        value === "google_interactions");
 }
 export function validCacheStrategy(value) {
     return (value === "explicit_anthropic_blocks" ||