@riemannre3/dsh-roleplay 0.1.3

package/lib/session-runtime.js

@@ -0,0 +1,324 @@
+// Keep the context prefix stable: it is persisted in existing DSH Sessions.
+export const TAVERN_CONTEXT_PREFIX = "dsh-re3-rp:";
+export const TAVERN_PLUGIN_ID = "dsh-roleplay";
+export const LEGACY_TAVERN_PLUGIN_ID = "dsh-re3-rp";
+export function isTavernPluginId(value) {
+    return value === TAVERN_PLUGIN_ID || value === LEGACY_TAVERN_PLUGIN_ID;
+}
+export const TAVERN_WORLD_CONTEXT_MARKER = "[DSH_RE3_RP_WORLD_CONTEXT]";
+export const TAVERN_ASSEMBLY_MARKER = "[DSH_RE3_RP_ASSEMBLY]";
+function tavernAssemblyMessage(summary, contextText) {
+    const changeParts = [
+        summary.addedEntryIds.length > 0 ? `+${summary.addedEntryIds.length}` : "",
+        summary.removedEntryIds.length > 0 ? `−${summary.removedEntryIds.length}` : "",
+    ].filter(Boolean);
+    const title = summary.stage === "prepared" ? "酒馆预设已准备" : "酒馆上下文已装配";
+    const text = contextText ?? `${TAVERN_ASSEMBLY_MARKER}\n${title}\n${summary.activeEntries} 项世界书激活 · ${summary.depthInjections} 项深度插入${changeParts.length > 0 ? ` · ${changeParts.join(" / ")}` : ""}`;
+    return {
+        id: crypto.randomUUID(),
+        role: "user",
+        content: [{ type: "text", text }],
+        source: {
+            kind: "plugin",
+            plugin: TAVERN_PLUGIN_ID,
+            form: "assembly",
+            assemblyId: summary.assemblyId,
+            assembly: summary,
+        },
+    };
+}
+export function appendTavernAssemblyEvent(session, summary, contextText) {
+    const event = session.append("user/message", tavernAssemblyMessage(summary, contextText), { surfaceOp: "append" });
+    return event.seq;
+}
+export function currentAssemblySurfaceSeq(session) {
+    return session?.surface?.nodes?.find((seq) => {
+        const event = session.events?.[seq];
+        const message = event?.data?.message ?? event?.data;
+        return event?.type === "user/message" && message?.source?.kind === "plugin" && isTavernPluginId(message.source.plugin) && message.source.form === "assembly";
+    });
+}
+export function upsertTavernAssemblyContext(session, summary, contextText) {
+    const previous = currentAssemblySurfaceSeq(session);
+    if (previous === undefined)
+        return appendTavernAssemblyEvent(session, summary, contextText);
+    const event = session.append("user/message", tavernAssemblyMessage(summary, contextText), {
+        surfaceOp: { op: "replace", start: previous, end: previous },
+        sourceEventSeqs: [previous],
+    });
+    return event.seq;
+}
+export function createTavernSessionSeed(openingText, sections = [], time = Date.now(), preparedAssembly) {
+    const events = [];
+    const append = (type, data, surfaceOp) => {
+        events.push({
+            seq: events.length,
+            time,
+            type,
+            data,
+            ...(surfaceOp === undefined ? {} : { surfaceOp }),
+        });
+    };
+    if (sections.length > 0) {
+        append("user/message", {
+            id: crypto.randomUUID(),
+            role: "user",
+            content: [{ type: "text", text: renderWorldbookSnapshot(sections) }],
+            source: {
+                kind: "plugin",
+                plugin: TAVERN_PLUGIN_ID,
+                form: "snapshot",
+                sections,
+            },
+        }, "append");
+    }
+    if (preparedAssembly !== undefined)
+        append("user/message", tavernAssemblyMessage(preparedAssembly), "append");
+    const turn = 1;
+    const step = 1;
+    append("turn/start", { turn });
+    append("step/start", { turn, step });
+    append("assistant/message", {
+        turn,
+        step,
+        message: {
+            id: crypto.randomUUID(),
+            role: "assistant",
+            content: [{ type: "text", text: openingText }],
+            source: { kind: "model", provider: TAVERN_PLUGIN_ID, model: "character-card-opening" },
+        },
+    }, "append");
+    append("step/end", { turn, step });
+    append("turn/end", { turn, reason: { kind: "completed" } });
+    return events;
+}
+export function isPlayerMessage(event) {
+    if (event?.type !== "user/message")
+        return false;
+    const message = event.data?.message ?? event.data;
+    return message?.source?.kind !== "plugin";
+}
+export function hasPlayerMessage(events) {
+    return events.some(isPlayerMessage);
+}
+export function currentOpeningSurfaceSeq(session) {
+    return session?.surface?.nodes?.find((seq) => session.events?.[seq]?.type === "assistant/message");
+}
+export function currentOpeningText(session) {
+    const seq = currentOpeningSurfaceSeq(session);
+    if (seq === undefined)
+        return undefined;
+    const event = session.events?.[seq];
+    return messageText(event?.data?.message ?? event?.data);
+}
+function messageText(message) {
+    if (typeof message?.content === "string")
+        return message.content;
+    if (!Array.isArray(message?.content))
+        return "";
+    return message.content
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+export function currentWorldbookSurfaceSeq(session) {
+    return session?.surface?.nodes?.find((seq) => {
+        const event = session.events?.[seq];
+        if (event?.type !== "user/message")
+            return false;
+        const message = event.data?.message ?? event.data;
+        return message?.source?.kind === "plugin" && isTavernPluginId(message.source.plugin) && messageText(message).startsWith(TAVERN_WORLD_CONTEXT_MARKER);
+    });
+}
+export function worldbookContextRevision(session) {
+    return (session?.events ?? []).filter((event) => {
+        if (event?.type !== "user/message")
+            return false;
+        const message = event.data?.message ?? event.data;
+        return message?.source?.kind === "plugin" && isTavernPluginId(message.source.plugin) && messageText(message).startsWith(TAVERN_WORLD_CONTEXT_MARKER);
+    }).length;
+}
+function surfaceEventKind(event) {
+    if (event?.type === "user/message") {
+        const message = event.data?.message ?? event.data;
+        if (message?.source?.kind === "plugin" && isTavernPluginId(message.source.plugin) && message.source.form === "assembly")
+            return "assembly";
+        if (message?.source?.kind === "plugin" && isTavernPluginId(message.source.plugin) && messageText(message).startsWith(TAVERN_WORLD_CONTEXT_MARKER))
+            return "worldbook";
+        if (message?.source?.kind === "plugin")
+            return "context";
+        return "user";
+    }
+    if (event?.type === "assistant/message") {
+        const message = event.data?.message ?? event.data;
+        if (isTavernPluginId(message?.source?.provider) && message.source.model === "character-card-opening")
+            return "opening";
+        return "assistant";
+    }
+    if (event?.type === "tool/result")
+        return "tool";
+    return undefined;
+}
+function surfaceEventText(event) {
+    const message = event?.data?.message ?? event?.data;
+    const text = messageText(message);
+    if (text.length > 0)
+        return text;
+    if (event?.type !== "tool/result")
+        return "";
+    try {
+        return JSON.stringify(event.data?.result ?? event.data, null, 2);
+    }
+    catch {
+        return "";
+    }
+}
+function surfaceEventLabel(kind, operation) {
+    if (kind === "assembly")
+        return "酒馆上下文已装配";
+    const noun = kind === "worldbook" ? "世界书上下文"
+        : kind === "opening" ? "开场"
+            : kind === "context" ? "上下文"
+                : kind === "user" ? "用户消息"
+                    : kind === "assistant" ? "助手消息"
+                        : "工具结果";
+    return `${noun}${operation === "append" ? "已追加" : "已替换"}`;
+}
+function surfaceTrajectoryRowKey(event, seq, kind) {
+    if (kind === "assembly" || kind === "worldbook" || kind === "context")
+        return `context\u0000seq\u0000${seq}`;
+    if (kind === "assistant" || kind === "opening") {
+        const turn = Number(event?.data?.turn);
+        const step = Number(event?.data?.step);
+        if (Number.isInteger(turn) && Number.isInteger(step))
+            return `assistant\u0000${turn}\u0000${step}`;
+    }
+    if (kind === "tool") {
+        const turn = Number(event?.data?.turn);
+        const step = Number(event?.data?.step);
+        if (Number.isInteger(turn) && Number.isInteger(step))
+            return `tool\u0000${turn}\u0000${step}`;
+    }
+    return `user\u0000seq\u0000${seq}`;
+}
+function replacedSeqs(event) {
+    const operation = event?.surfaceOp;
+    if (operation === null || typeof operation !== "object" || operation.op !== "replace")
+        return [];
+    const start = Number(operation.start);
+    const end = Number(operation.end);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || end < start)
+        return [];
+    return Array.from({ length: end - start + 1 }, (_, index) => start + index);
+}
+export function tavernSurfaceAudit(session) {
+    const active = new Set(Array.isArray(session?.surface?.nodes) ? session.surface.nodes : []);
+    const entries = (Array.isArray(session?.events) ? session.events : []).flatMap((event, index) => {
+        const kind = surfaceEventKind(event);
+        if (kind === undefined)
+            return [];
+        const message = event.data?.message ?? event.data;
+        const operation = event.surfaceOp === "append" ? "append" : event.surfaceOp?.op === "replace" ? "replace" : undefined;
+        if (operation === undefined)
+            return [];
+        const sections = Array.isArray(message?.source?.sections) ? message.source.sections : [];
+        const assembly = kind === "assembly" && message?.source?.assembly && typeof message.source.assembly === "object" ? message.source.assembly : undefined;
+        const seq = Number.isInteger(event.seq) ? event.seq : index;
+        const replacement = replacedSeqs(event);
+        return [{
+                seq,
+                time: Number.isFinite(event.time) ? event.time : null,
+                kind,
+                label: surfaceEventLabel(kind, operation),
+                operation,
+                active: active.has(seq),
+                replaces: replacement,
+                replacedBy: [],
+                sourceEventSeqs: Array.isArray(event.sourceEventSeqs) ? event.sourceEventSeqs.filter(Number.isInteger) : [],
+                trajectoryRowKey: surfaceTrajectoryRowKey(event, seq, kind),
+                sectionNames: sections.flatMap((section) => typeof section?.name === "string" ? [section.name] : []),
+                characterCount: surfaceEventText(event).length,
+                ...(assembly === undefined ? {} : { assembly }),
+            }];
+    });
+    const replacedBy = new Map();
+    for (const entry of entries)
+        for (const target of entry.replaces)
+            replacedBy.set(target, [...(replacedBy.get(target) ?? []), entry.seq]);
+    return entries.map((entry) => ({
+        ...entry,
+        replacedBy: replacedBy.get(entry.seq) ?? [],
+        trajectoryRowKey: surfaceTrajectoryRowKey(session.events?.[entry.seq], entry.seq, entry.kind),
+    }));
+}
+export function tavernSurfaceEventDetail(session, seq) {
+    const audit = tavernSurfaceAudit(session).find((entry) => entry.seq === seq);
+    const event = session?.events?.[seq];
+    if (audit === undefined || event === undefined)
+        return undefined;
+    const message = event.data?.message ?? event.data;
+    const sections = Array.isArray(message?.source?.sections)
+        ? message.source.sections.flatMap((section) => typeof section?.name === "string" && typeof section?.text === "string" ? [{ name: section.name, text: section.text }] : [])
+        : [];
+    return { ...audit, content: surfaceEventText(event), sections };
+}
+export function renderWorldbookSnapshot(sections) {
+    const body = sections.length === 0
+        ? "当前没有生效的世界书条目。"
+        : sections.map((section) => `[${section.name}]\n${section.text}`).join("\n\n");
+    return `${TAVERN_WORLD_CONTEXT_MARKER}\n这是当前对话对应的世界书事实快照。不要向玩家提及世界书、快照或插件。\n\n${body}`;
+}
+export function upsertWorldbookContext(session, sections) {
+    const text = renderWorldbookSnapshot(sections);
+    const currentSeq = currentWorldbookSurfaceSeq(session);
+    const currentEvent = currentSeq === undefined ? undefined : session.events?.[currentSeq];
+    const currentMessage = currentEvent?.data?.message ?? currentEvent?.data;
+    const currentText = messageText(currentMessage);
+    const currentRevision = worldbookContextRevision(session);
+    if (currentSeq !== undefined && currentText === text)
+        return { changed: false, seq: currentSeq, revision: currentRevision };
+    const revision = currentRevision + 1;
+    const message = {
+        id: crypto.randomUUID(),
+        role: "user",
+        content: [{ type: "text", text }],
+        source: {
+            kind: "plugin",
+            plugin: TAVERN_PLUGIN_ID,
+            form: "snapshot",
+            sections,
+        },
+    };
+    const event = currentSeq === undefined
+        ? session.append("user/message", message, { surfaceOp: "append" })
+        : session.append("user/message", message, {
+            surfaceOp: { op: "replace", start: currentSeq, end: currentSeq },
+            sourceEventSeqs: [currentSeq],
+        });
+    return { changed: true, seq: event.seq, revision };
+}
+export function isolateTavernAssembly(assembly) {
+    return {
+        ...assembly,
+        contexts: (assembly.contexts ?? []).filter((context) => typeof context?.name === "string" && context.name.startsWith(TAVERN_CONTEXT_PREFIX)),
+        tools: [],
+    };
+}
+export function adjacentOpeningId(openings, currentId, offset) {
+    if (openings.length === 0)
+        return undefined;
+    const current = Math.max(0, openings.findIndex((opening) => opening.id === currentId));
+    return openings[(current + offset % openings.length + openings.length) % openings.length]?.id;
+}
+export function openingIdFromSetChatMessages(messages, openings) {
+    if (!Array.isArray(messages) || messages.length !== 1)
+        return undefined;
+    const selection = messages[0];
+    if (selection === null || typeof selection !== "object" || Array.isArray(selection))
+        return undefined;
+    const { message_id: messageId, swipe_id: swipeId } = selection;
+    if (messageId !== 0 || !Number.isInteger(swipeId) || swipeId < 0)
+        return undefined;
+    const openingId = `opening-${swipeId}`;
+    return openings.some((opening) => opening.id === openingId) ? openingId : undefined;
+}

package/lib/split-mvu.js

@@ -0,0 +1,85 @@
+import { applyVariableUpdate } from "./variable-runtime.js";
+function entryPhase(entry) {
+    if (/\[mvu_plot\]/iu.test(entry.comment))
+        return "plot";
+    if (/\[mvu_update\]/iu.test(entry.comment))
+        return "update";
+    return undefined;
+}
+export function hasSplitMvuContract(entries) {
+    let hasPlot = false;
+    let hasUpdate = false;
+    for (const entry of entries) {
+        const phase = entryPhase(entry);
+        if (phase === "plot")
+            hasPlot = true;
+        if (phase === "update")
+            hasUpdate = true;
+    }
+    return hasPlot && hasUpdate;
+}
+export function splitMvuActivationForPhase(activation, phase) {
+    return {
+        ...activation,
+        active: activation.active.filter((entry) => {
+            const taggedPhase = entryPhase(entry);
+            return taggedPhase === undefined || taggedPhase === phase;
+        }),
+    };
+}
+/**
+ * Tavern MVU prompts commonly emit JSON Patch `replace` for a leaf that has not
+ * appeared in the current snapshot yet. Keep the core variable runtime strict,
+ * but make that one ecosystem compatibility concession for the isolated
+ * secondary MVU phase. Every rewrite is followed by a complete atomic replay;
+ * unrelated path/type errors remain failures.
+ */
+export function applySplitMvuPatchCompatibility(before, body) {
+    const blocks = [];
+    const matcher = /<JSON_?Patch\b[^>]*>([\s\S]*?)<\/JSON_?Patch>/giu;
+    for (const match of body.matchAll(matcher)) {
+        try {
+            const parsed = JSON.parse(match[1].trim());
+            if (!Array.isArray(parsed))
+                return { body, result: applyVariableUpdate(before, body), repairedPaths: [] };
+            blocks.push({ source: match[0], items: parsed });
+        }
+        catch {
+            return { body, result: applyVariableUpdate(before, body), repairedPaths: [] };
+        }
+    }
+    if (blocks.length === 0)
+        return { body, result: applyVariableUpdate(before, body), repairedPaths: [] };
+    const render = () => {
+        let rendered = body;
+        for (const block of blocks) {
+            const tag = /^<JSON_?Patch\b[^>]*>/iu.exec(block.source)?.[0] ?? "<JSONPatch>";
+            const close = /<\/JSON_?Patch>$/iu.exec(block.source)?.[0] ?? "</JSONPatch>";
+            rendered = rendered.replace(block.source, `${tag}${JSON.stringify(block.items)}${close}`);
+        }
+        return rendered;
+    };
+    const repairedPaths = [];
+    let candidate = body;
+    let result = applyVariableUpdate(before, candidate);
+    for (let repairCount = 0; result.status === "failed" && repairCount < 64; repairCount += 1) {
+        const diagnostic = result.diagnostics.find((item) => item.code === "PATH_NOT_FOUND" && item.operation === "replace" && typeof item.path === "string");
+        if (diagnostic?.path === undefined)
+            break;
+        let repaired = false;
+        for (const block of blocks) {
+            const item = block.items.find((entry) => String(entry.op).toLocaleLowerCase() === "replace" && entry.path === diagnostic.path);
+            if (item === undefined)
+                continue;
+            item.op = "insert";
+            repairedPaths.push(diagnostic.path);
+            repaired = true;
+            break;
+        }
+        if (!repaired)
+            break;
+        candidate = render();
+        result = applyVariableUpdate(before, candidate);
+    }
+    return { body: candidate, result, repairedPaths };
+}