narraeon 0.4.0 → 0.5.1

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

@@ -29,7 +29,24 @@ export async function runPlayFollowupRequests(input) {
             failure ??= "The follow-up request was cancelled.";
             break;
         }
-        const outcome = await runOne(input, followup, prefix);
+        const lease = await input.controls?.acquire(input.context.worldId, {
+            playPresetId: input.context.playPresetId,
+            requestId: followup.id,
+            ...(followup.extensionControl === undefined
+                ? {}
+                : { extensionControl: followup.extensionControl }),
+        }, input.signal);
+        if (lease?.signal.aborted) {
+            lease.release();
+            continue;
+        }
+        let outcome;
+        try {
+            outcome = await runOne(input, followup, prefix, lease?.signal ?? input.signal);
+        }
+        finally {
+            lease?.release();
+        }
         if (signalWasAborted(input.signal)) {
             failure ??= "The follow-up request was cancelled.";
             break;
@@ -46,7 +63,7 @@ export async function runPlayFollowupRequests(input) {
         : await input.artifacts.failExtension(input.context.operationId, "recovery_required", failure, completed);
     return { outcomes, extension };
 }
-async function runOne(input, followup, prefix) {
+async function runOne(input, followup, prefix, requestSignal) {
     const outcome = {
         id: followup.id,
         displayName: followup.displayName,
@@ -55,14 +72,25 @@ async function runOne(input, followup, prefix) {
     };
     const requestContext = {
         ...input.context,
+        ...(followup.extensionControl === undefined
+            ? {}
+            : { extensionControl: structuredClone(followup.extensionControl) }),
+        ...(input.presentations?.[followup.id] === undefined
+            ? {}
+            : { frozenPresentations: input.presentations[followup.id] }),
         requestId: followup.id,
+        displayName: followup.displayName,
         requestAttempt: 1,
         maxArtifactBytes: followup.maxArtifactBytes,
         declarations: structuredClone(followup.artifacts),
+        ...(followup.frozenResources === undefined
+            ? {}
+            : { frozenResources: structuredClone(followup.frozenResources) }),
     };
     let responseDiagnostics;
     try {
         await input.artifacts.beginRequestAttempt(requestContext);
+        requestSignal?.throwIfAborted();
         input.observer?.onProviderDispatch?.();
         let response;
         try {
@@ -87,7 +115,7 @@ async function runOne(input, followup, prefix) {
                 exchange: 1,
                 maxOutputTokens: input.maxOutputTokens,
             }, {
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
+                ...(requestSignal === undefined ? {} : { signal: requestSignal }),
                 onDelta: (delta) => input.observer?.onProviderDelta?.(delta),
             });
             if (input.signal?.aborted === true)
@@ -117,6 +145,8 @@ async function runOne(input, followup, prefix) {
             });
         }
         const failedTools = outcome.toolCalls.filter(({ ok }) => !ok);
+        if (failedTools.length > 0)
+            outcome.failure = `Follow-up request ${followup.id} could not save its artifacts.`;
         if (failedTools.length > 0 && response.diagnostics !== undefined)
             await input.failureLog?.recordFailure({
                 exchange: response.diagnostics,
@@ -168,6 +198,7 @@ async function runOne(input, followup, prefix) {
                 ],
             });
     }
+    await input.artifacts.finishRequest?.(requestContext, outcome.failure !== undefined);
     return outcome;
 }
 function signalWasAborted(signal) {

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

@@ -1,15 +1,38 @@
-import { parsePlayPresetRegexAsset, toPlayPresetStructuredEditor, } from "./FileNativePlayPresetStore.js";
+import { resolveArtifactRenderer } from "../extension/FrontendExtensionBundle.js";
+import { builtinFollowupExample } from "../../shared/ordered-followups.js";
+import { projectPlayerViewPanels, } from "../extension/PlayerViewPanelProjector.js";
+import { parsePlayPresetRegexAsset, applyPlayPresetStructuredEditor, parsePlayPresetStructuredEditor, parsePlayPresetFiles, revisionForPlayPresetFiles, toPlayPresetStructuredEditor, } from "./FileNativePlayPresetStore.js";
 /**
  * Read-only workbench seam. It resolves the same frozen file-native binding
  * used by PromptCompiler and FrontendExtensionBundle, but never calls a model,
  * writes a world, or executes author JavaScript.
  */
-export function buildPlayPresetWorkbenchSnapshot(binding) {
+export function buildPlayPresetWorkbenchSnapshot(binding, playerViewContext, draft) {
+    if (draft !== undefined) {
+        const files = draft.structure === undefined
+            ? structuredClone(draft.files)
+            : applyPlayPresetStructuredEditor(draft.files, parsePlayPresetStructuredEditor(draft.structure));
+        const parsed = parsePlayPresetFiles(files);
+        if (parsed.kind === "invalid")
+            throw parsed.error;
+        binding = {
+            ...binding,
+            files,
+            definition: parsed.definition,
+            revision: revisionForPlayPresetFiles(files),
+        };
+    }
     const scriptsEnabled = binding.scriptsEnabled !== false;
     const structure = toPlayPresetStructuredEditor(binding.definition);
     const staticErrors = [];
     const artifactPreviews = [];
-    for (const followup of binding.definition.followups)
+    const previewFollowups = [
+        ...binding.definition.followups,
+        ...(binding.definition.followupItems === undefined
+            ? []
+            : [builtinFollowupExample("en").definition]),
+    ];
+    for (const followup of previewFollowups)
         for (const declaration of followup.artifacts) {
             const diagnostics = [];
             let regex = [];
@@ -41,57 +64,17 @@ export function buildPlayPresetWorkbenchSnapshot(binding) {
                         ? "<p>This is a local HTML workbench sample.</p>"
                         : "This is a local text workbench sample.";
             let renderer;
-            if (declaration.renderer !== undefined) {
-                const source = binding.files[declaration.renderer];
-                if (source === undefined) {
-                    const message = `Renderer resource does not exist: ${declaration.renderer}`;
-                    diagnostics.push(message);
-                    staticErrors.push({
-                        code: "renderer_missing",
-                        message,
-                        location: declaration.renderer,
-                    });
-                }
-                else {
-                    const scriptSources = (declaration.scripts ?? []).flatMap((path) => {
-                        const script = binding.files[path];
-                        if (script === undefined) {
-                            diagnostics.push(`Script resource does not exist: ${path}`);
-                            staticErrors.push({
-                                code: "script_missing",
-                                message: `Script resource does not exist: ${path}`,
-                                location: path,
-                            });
-                            return [];
-                        }
-                        return [script];
-                    });
-                    const assetSources = (declaration.assets ?? []).flatMap((path) => {
-                        const asset = binding.files[path];
-                        if (asset === undefined) {
-                            diagnostics.push(`Asset resource does not exist: ${path}`);
-                            staticErrors.push({
-                                code: "asset_missing",
-                                message: `Asset resource does not exist: ${path}`,
-                                location: path,
-                            });
-                            return [];
-                        }
-                        return [{ id: path, source: asset }];
-                    });
-                    renderer = {
-                        mode: declaration.rendererMode ?? "document",
-                        ...(declaration.rendererRevision === undefined
-                            ? {}
-                            : { revision: declaration.rendererRevision }),
-                        document: source,
-                        scripts: scriptsEnabled ? scriptSources : [],
-                        assets: assetSources,
-                        trustedLocalCode: scriptsEnabled &&
-                            (declaration.contentType === "text/html" ||
-                                (declaration.scripts?.length ?? 0) > 0),
-                    };
-                }
+            try {
+                renderer = resolveArtifactRenderer(declaration, binding);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Invalid renderer resources";
+                diagnostics.push(message);
+                staticErrors.push({
+                    code: "renderer_invalid",
+                    message,
+                    location: declaration.renderer ?? followup.id,
+                });
             }
             artifactPreviews.push({
                 requestId: followup.id,
@@ -125,6 +108,14 @@ export function buildPlayPresetWorkbenchSnapshot(binding) {
         revision: binding.revision,
         structure,
         artifactPreviews,
+        ...(playerViewContext === undefined
+            ? {}
+            : {
+                playerViewPreview: {
+                    ...playerViewContext,
+                    panels: projectPlayerViewPanels({ ...playerViewContext, binding }),
+                },
+            }),
         staticErrors,
         trustedLocalCode: artifactPreviews.some(({ renderer }) => renderer?.trustedLocalCode === true),
         scriptsEnabled,

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

@@ -0,0 +1,86 @@
+import { validPromptCompilation, validPromptTools, validPlayFollowup, } from "../prompt/PromptCompilationCodec.js";
+import { createHash } from "node:crypto";
+export function currentPlayPrompt(source) {
+    return source.promptRuns?.at(-1) ?? source;
+}
+export function recordedPlayPrompt(source) {
+    const lastEvent = source.events.at(-1)?.id ?? 0;
+    return (source.promptRuns?.findLast((run) => run.firstEventId <= lastEvent) ??
+        source);
+}
+export function playPromptRunsThroughEvents(context, events) {
+    const lastEvent = events.at(-1)?.id ?? 0;
+    const runs = (context.promptRuns ?? []).filter(({ firstEventId }) => firstEventId <= lastEvent);
+    return structuredClone([
+        ...new Map(runs.map((run) => [run.firstEventId, run])).values(),
+    ]);
+}
+export function assertPlayPromptRun(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("Invalid play prompt run");
+    const run = value;
+    if (!exactKeys(run, [
+        "schemaVersion",
+        "firstEventId",
+        "head",
+        "exchange",
+        "playPreset",
+        "bootstrap",
+        "tools",
+        "followups",
+        "playPresetScriptsEnabled",
+        "presetFiles",
+    ]) ||
+        run.schemaVersion !== 1 ||
+        !Number.isSafeInteger(run.firstEventId) ||
+        Number(run.firstEventId) < 1 ||
+        !Number.isSafeInteger(run.exchange) ||
+        Number(run.exchange) < 1 ||
+        typeof run.head !== "string" ||
+        !validPresetIdentity(run.playPreset) ||
+        !validPromptCompilation(run.bootstrap) ||
+        !validPromptTools(run.tools) ||
+        !Array.isArray(run.followups) ||
+        !run.followups.every(validPlayFollowup) ||
+        typeof run.playPresetScriptsEnabled !== "boolean" ||
+        typeof run.presetFiles !== "object" ||
+        run.presetFiles === null ||
+        Array.isArray(run.presetFiles) ||
+        !Object.values(run.presetFiles).every((contents) => typeof contents === "string"))
+        throw new Error("Invalid play prompt run");
+}
+export function encodePlayPromptRun(run) {
+    assertPlayPromptRun(run);
+    return {
+        kind: "play_prompt_run",
+        schemaVersion: 1,
+        run,
+        digest: createHash("sha256").update(JSON.stringify(run)).digest("hex"),
+    };
+}
+export function decodePlayPromptRun(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("Invalid play prompt run record");
+    const record = value;
+    if (!exactKeys(record, ["kind", "schemaVersion", "run", "digest"]) ||
+        record.kind !== "play_prompt_run" ||
+        record.schemaVersion !== 1 ||
+        record.digest !==
+            createHash("sha256")
+                .update(JSON.stringify(record.run) ?? "")
+                .digest("hex"))
+        throw new Error("Play prompt run does not match its durable identity");
+    assertPlayPromptRun(record.run);
+    return record.run;
+}
+function exactKeys(record, keys) {
+    return (Object.keys(record).length === keys.length &&
+        keys.every((key) => Object.hasOwn(record, key)));
+}
+function validPresetIdentity(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    const preset = value;
+    return (exactKeys(preset, ["id", "name", "revision"]) &&
+        [preset.id, preset.name, preset.revision].every((part) => typeof part === "string" && part.length > 0));
+}