narraeon 0.5.6 → 0.5.7

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

@@ -1,8 +1,9 @@
+var _a;
 import { createHash } from "node:crypto";
 import { appendFile, chmod, mkdir, stat } from "node:fs/promises";
 import { dirname } from "node:path";
 import { hasCLIProxyThinkingSuffix, modelReasoningPolicyIssue, } from "../../protocol/modelConnections.js";
-import { ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
+import { assertModelOutputComplete, ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
 import { renderPromptDeltaMessage, } from "../prompt/FileNativePromptCompiler.js";
 import { aggregateAnthropicModelStream, aggregateChatModelStream, aggregateResponsesModelStream, } from "./ModelHostStream.js";
 import { defaultRuntimeToolDefinitionStrategy, portableRuntimeToolInputSchema, } from "../prompt/FileNativeToolRegistry.js";
@@ -77,7 +78,31 @@ export class FileNativeModelHost {
                 .digest("hex"),
         };
     }
-    async exchange(request, observer) {
+    freezeRequest(request) {
+        const frozen = structuredClone(request);
+        if (frozen.modelConfig === undefined) {
+            const { baseUrl: _baseUrl, apiKey: _apiKey, ...config } = this.#connection;
+            void _baseUrl;
+            void _apiKey;
+            frozen.modelConfig = config;
+        }
+        return frozen;
+    }
+    #requestHost(request) {
+        if (request.modelConfig === undefined)
+            return this;
+        if (request.modelConfig.provider !== this.#connection.provider)
+            throw new ModelHostBindingMismatchError("The request protocol does not match the selected model host");
+        return new _a({
+            ...request.modelConfig,
+            baseUrl: this.#connection.baseUrl,
+            apiKey: this.#connection.apiKey,
+        }, this.#fetch, this.#failureLog);
+    }
+    exchange(request, observer) {
+        return this.#requestHost(request).#exchange(request, observer);
+    }
+    async #exchange(request, observer) {
         assertExchangeCompatibility(this.#connection, request);
         await trace("model_host_exchange", modelHostTrace(request));
         const signal = observer?.signal;
@@ -99,6 +124,9 @@ export class FileNativeModelHost {
     }
     /** Uses the production encoders and deliberately omits credentials. */
     previewRequest(request) {
+        return this.#requestHost(request).#previewRequest(request);
+    }
+    #previewRequest(request) {
         assertExchangeCompatibility(this.#connection, request);
         const provider = this.#connection.provider;
         const body = provider === "chat_completions"
@@ -183,6 +211,7 @@ export class FileNativeModelHost {
             await trace("chat_response", payload);
             const message = payload.choices?.[0]?.message;
             const finishReason = payload.choices?.[0]?.finish_reason;
+            assertModelOutputComplete(finishReason);
             if (message === undefined)
                 throw unknownProviderResponse("Chat Completions");
             if (finishReason !== undefined &&
@@ -271,6 +300,7 @@ export class FileNativeModelHost {
             if (!isRecord(rawPayload) || !Array.isArray(rawPayload.content))
                 throw unknownProviderResponse("Anthropic Messages");
             const payload = rawPayload;
+            assertModelOutputComplete(payload.stop_reason);
             const content = payload.content;
             if (!validAnthropicContent(content))
                 throw unknownProviderResponse("Anthropic Messages");
@@ -310,6 +340,7 @@ export class FileNativeModelHost {
         });
     }
 }
+_a = FileNativeModelHost;
 function assertExchangeCompatibility(connection, request) {
     if (request.bootstrap.provider.protocol !== connection.provider)
         throw new ModelHostBindingMismatchError("The compiled prompt protocol does not match the selected model host");
@@ -1048,6 +1079,7 @@ async function openAIResponsesRequest(input) {
         await trace(`${input.tracePrefix}_response`, payload);
         if (!isRecord(payload) || !Array.isArray(payload.output))
             throw unknownProviderResponse("Responses API");
+        assertModelOutputComplete(responsesStopReason(payload));
         const output = cloneResponseOutput(payload.output);
         if (!validResponsesOutput(output))
             throw unknownProviderResponse("Responses API");

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

@@ -33,10 +33,21 @@ export class ModelHostFailureError extends Error {
             this.details = options.details;
     }
 }
-/** A Provider has rejected the complete request because its context is full. */
+/** Reject provider-confirmed truncation before accepting text or tool calls. */
+export function assertModelOutputComplete(stopReason) {
+    if (stopReason === "length" ||
+        stopReason === "max_tokens" ||
+        stopReason === "max_output_tokens" ||
+        stopReason === "incomplete:max_output_tokens") {
+        throw new ModelHostFailureError("The model response reached the output token limit before completion. Increase maxOutputTokens and start a fresh context; reasoning may also consume the output budget.", { details: { code: "model_output_limit", stopReason } });
+    }
+}
+/** Replaying the frozen request cannot recover a context or output limit. */
 export function modelHostFailureRequiresFreshContext(error) {
     if (!(error instanceof ModelHostFailureError))
         return false;
+    if (failureDetailStrings(error.details).includes("model_output_limit"))
+        return true;
     const evidence = [error.message, ...failureDetailStrings(error.details)]
         .join("\n")
         .toLocaleLowerCase("und");

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

@@ -1,4 +1,4 @@
-import { ModelHostFailureError } from "./ModelHost.js";
+import { assertModelOutputComplete, ModelHostFailureError, } from "./ModelHost.js";
 import { providerStreamEvents } from "./ProviderStream.js";
 export async function aggregateChatModelStream(body, onDelta) {
     let content = "";
@@ -110,6 +110,7 @@ export async function aggregateChatModelStream(body, onDelta) {
     }
     if (!completed || !sawPayload)
         throw new Error("Chat SSE ended before a complete response");
+    assertModelOutputComplete(stopReason);
     const toolCalls = [...calls.entries()]
         .sort(([left], [right]) => left - right)
         .map(([, call]) => {
@@ -259,8 +260,6 @@ export async function aggregateAnthropicModelStream(body, onDelta) {
                 if (block === undefined || block.stopped)
                     throw new Error("Anthropic SSE content block stop is invalid");
                 block.stopped = true;
-                if (block.value.type === "tool_use" && block.partialJson !== "")
-                    block.value.input = parseStreamJson(block.partialJson);
                 break;
             }
             case "message_delta": {
@@ -289,11 +288,14 @@ export async function aggregateAnthropicModelStream(body, onDelta) {
     }
     if (!started || !stopped)
         throw new Error("Anthropic SSE ended before a complete response");
+    assertModelOutputComplete(stopReason);
     const content = [...blocks.entries()]
         .sort(([left], [right]) => left - right)
         .map(([, block]) => {
         if (!block.stopped)
             throw new Error("Anthropic SSE content block did not end");
+        if (block.value.type === "tool_use" && block.partialJson !== "")
+            block.value.input = parseStreamJson(block.partialJson);
         return block.value;
     });
     const text = content
@@ -364,6 +366,12 @@ export async function aggregateResponsesModelStream(body, onDelta) {
             payload.type === "response.incomplete" ||
             payload.type === "response.cancelled" ||
             payload.type === "error") {
+            if (payload.type === "response.incomplete" &&
+                isRecord(payload.response)) {
+                const details = payload.response.incomplete_details;
+                if (isRecord(details))
+                    assertModelOutputComplete(details.reason);
+            }
             throw new ModelHostFailureError("Responses SSE returned an explicit failure");
         }
     }

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

@@ -1,3 +1,5 @@
+import { legacyModelBindingFailure, projectLegacyModelBindingFailure, } from "./LegacyModelBindingFailure.js";
+import { isPlayFailureKind, } from "../../protocol/playFailure.js";
 import { isNarrativeOrigin, } from "../history/HistoryBackground.js";
 import { encodePlayPromptRun, decodePlayPromptRun, } from "./PlayPromptRun.js";
 import { createHash, randomUUID } from "node:crypto";
@@ -71,7 +73,8 @@ export class FileNativePlayTimelineStore {
         const eventCount = prefixLength(input.source.events, input.target.events);
         const completedToolCount = prefixLength(input.source.completedTools, input.target.completedTools);
         const authorizationCheckpointCount = prefixLength(input.source.documentAuthorizationCheckpoints ?? [], input.target.documentAuthorizationCheckpoints ?? []);
-        if (input.target.events.some((event) => event.kind === "assistant" && event.status === "completed")) {
+        if (input.retainCompleteContext ||
+            input.target.events.some((event) => event.kind === "assistant" && event.status === "completed")) {
             const encoding = await this.readInitialEncoding(input.sourceWorldId, input.source.chainId).catch(() => null);
             if (encoding !== null)
                 await publishImmutableJson(join(targetRoot, "initial-request-encoding.json"), encoding);
@@ -207,6 +210,9 @@ export class FileNativePlayTimelineStore {
             continuationDigest,
             lastRequestAttempt: value.lastRequestAttempt,
             lastFailure: value.lastFailure,
+            ...(value.lastFailureKind === undefined
+                ? {}
+                : { lastFailureKind: value.lastFailureKind }),
             updatedAt: value.updatedAt,
         };
         await publishJson(join(root, "state.json"), state);
@@ -235,6 +241,20 @@ export class FileNativePlayTimelineStore {
             throw new Error("Play timeline head generation is inconsistent");
         return loaded;
     }
+    /** Read only the small active context index, never its transcript or bootstrap. */
+    async currentContextRequiresFreshContext(worldId) {
+        assertIdentity(worldId, "World ID");
+        const head = await this.#readTimelineHead(worldId);
+        if (head === null)
+            return false;
+        const index = await readJson(join(this.#contextRoot(worldId, head.chainId), "index.json"));
+        assertContextIndex(index);
+        if (index.worldId !== worldId ||
+            index.chainId !== head.chainId ||
+            index.timelineGeneration !== head.generation)
+            throw new Error("Play context durable identity is inconsistent");
+        return index.importedFromArchive === true;
+    }
     async readContext(worldId, chainId) {
         assertIdentity(worldId, "World ID");
         assertIdentity(chainId, "Call-chain ID");
@@ -277,6 +297,7 @@ export class FileNativePlayTimelineStore {
             chainId,
             previousChainId: indexValue.previousChainId,
             timelineGeneration: indexValue.timelineGeneration,
+            ...(indexValue.importedFromArchive ? { importedFromArchive: true } : {}),
             ...(baseValue.continuityContextId === undefined
                 ? {}
                 : { continuityContextId: baseValue.continuityContextId }),
@@ -327,6 +348,9 @@ export class FileNativePlayTimelineStore {
             lastRequest,
             lastRequestAttempt: stateValue.lastRequestAttempt,
             lastFailure: stateValue.lastFailure,
+            ...(stateValue.lastFailureKind === undefined
+                ? {}
+                : { lastFailureKind: stateValue.lastFailureKind }),
             updatedAt: stateValue.updatedAt,
         };
         return {
@@ -445,7 +469,10 @@ export class FileNativePlayTimelineStore {
                     kind: "event",
                     chainId: pointer.chainId,
                     current: pointer.chainId === head?.chainId,
-                    event: summary,
+                    ...(context.index.importedFromArchive
+                        ? { requiresFreshContext: true }
+                        : {}),
+                    event: projectLegacyModelBindingFailure(summary),
                 });
                 pointer = { ...pointer, eventId: pointer.eventId - 1 };
                 continue;
@@ -498,6 +525,9 @@ export class FileNativePlayTimelineStore {
             activeStatus: active?.state.status ?? null,
             activeCanRetry: active?.state.canRetry ?? false,
             activeLastFailure: active?.state.lastFailure ?? null,
+            ...(active?.state.lastFailureKind === undefined
+                ? {}
+                : { activeLastFailureKind: active.state.lastFailureKind }),
             items: reverse.reverse(),
             nextCursor: pointer.chainId === null && pointer.genesisIndex < 0
                 ? null
@@ -516,7 +546,7 @@ export class FileNativePlayTimelineStore {
         assertPlayEvent(event);
         if (event.id !== eventId)
             throw new Error("Play timeline event identity is inconsistent");
-        return normalizePlayEvent(event);
+        return projectLegacyModelBindingFailure(normalizePlayEvent(event));
     }
     newGeneration() {
         return `timeline:${randomUUID()}`;
@@ -597,11 +627,48 @@ export class FileNativePlayTimelineStore {
             indexValue.chainId !== chainId ||
             stateValue.chainId !== chainId)
             throw new Error("Play context durable identity is inconsistent");
+        // 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.
+        if (!indexValue.importedFromArchive &&
+            stateValue.status === "interrupted" &&
+            stateValue.lastFailure === legacyModelBindingFailure &&
+            (stateValue.lastFailureKind === undefined ||
+                stateValue.lastFailureKind === "context_unavailable")) {
+            for (let id = stateValue.eventCount; id > 0; id -= 1) {
+                const event = await readJson(join(root, "events", numbered(id)));
+                assertPlayEvent(event);
+                if (event.kind === "followup" ||
+                    (event.kind === "failure" &&
+                        event.message === legacyModelBindingFailure))
+                    continue;
+                if (event.kind === "assistant" &&
+                    event.status === "completed" &&
+                    event.responseKind === "narrative" &&
+                    event.continuation === "available" &&
+                    event.committedHead === stateValue.parentHead) {
+                    stateValue.status = "ready";
+                    stateValue.canRetry = false;
+                    stateValue.lastFailure = null;
+                    delete stateValue.lastFailureKind;
+                }
+                else if (event.kind === "failure") {
+                    stateValue.canRetry = event.failureKind === "retryable";
+                    stateValue.lastFailure = event.message;
+                    if (event.failureKind === undefined)
+                        delete stateValue.lastFailureKind;
+                    else
+                        stateValue.lastFailureKind = event.failureKind;
+                }
+                break;
+            }
+        }
         return { root, index: indexValue, state: stateValue };
     }
 }
 function contextIndex(value) {
     return {
+        ...(value.importedFromArchive ? { importedFromArchive: true } : {}),
         schemaVersion: 3,
         kind: "play_context_index",
         worldId: value.worldId,
@@ -724,6 +791,8 @@ function assertContextIndex(value) {
     if (!isRecord(value) ||
         value.schemaVersion !== 3 ||
         value.kind !== "play_context_index" ||
+        (value.importedFromArchive !== undefined &&
+            value.importedFromArchive !== true) ||
         typeof value.worldId !== "string" ||
         typeof value.chainId !== "string" ||
         (value.previousChainId !== null &&
@@ -769,6 +838,8 @@ function assertContextState(value) {
         !/^[a-f0-9]{64}$/u.test(value.continuationDigest) ||
         !validCount(value.lastRequestAttempt) ||
         (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
+        (value.lastFailureKind !== undefined &&
+            !isPlayFailureKind(value.lastFailureKind)) ||
         typeof value.updatedAt !== "number")
         throw new Error("Play context state has an invalid shape");
 }
@@ -839,6 +910,8 @@ function isReleasedPlayContext(value) {
         (value.lastRequest !== null && !isRecord(value.lastRequest)) ||
         !validCount(value.lastRequestAttempt) ||
         (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
+        (value.lastFailureKind !== undefined &&
+            !isPlayFailureKind(value.lastFailureKind)) ||
         typeof value.updatedAt !== "number")
         return false;
     try {
@@ -976,7 +1049,10 @@ function assertPlayEvent(value) {
         return;
     }
     if ((value.kind !== "failure" && value.kind !== "cancellation") ||
-        typeof value.message !== "string")
+        typeof value.message !== "string" ||
+        (value.kind === "failure" &&
+            value.failureKind !== undefined &&
+            !isPlayFailureKind(value.failureKind)))
         throw new Error("Play timeline event has an invalid kind");
 }
 function assertTimelineEventSummary(value) {

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

@@ -0,0 +1,10 @@
+export const legacyModelBindingFailure = "The selected model connection does not match the frozen model binding; start a fresh context.";
+/** Presentation only: immutable historical events remain unchanged on disk. */
+export function projectLegacyModelBindingFailure(event) {
+    if (event.kind === "failure" &&
+        event.message === legacyModelBindingFailure &&
+        (event.failureKind === undefined ||
+            event.failureKind === "context_unavailable"))
+        return { ...event, failureKind: "configuration_mismatch" };
+    return event;
+}