mirror of
https://github.com/Youzini-afk/ST-Bionic-Memory-Ecology.git
synced 2026-06-14 02:40:45 +08:00
475 lines
14 KiB
JavaScript
475 lines
14 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import {
|
|
installResolveHooks,
|
|
toDataModuleUrl,
|
|
} from "./helpers/register-hooks-compat.mjs";
|
|
|
|
const extensionsShimSource = [
|
|
"export const extension_settings = {};",
|
|
"export function getContext() {",
|
|
" return globalThis.__stBmeTestContext || {",
|
|
" chat: [],",
|
|
" chatMetadata: {},",
|
|
" extensionSettings: {},",
|
|
" powerUserSettings: {},",
|
|
" characters: {},",
|
|
" characterId: null,",
|
|
" name1: '玩家',",
|
|
" name2: '艾琳',",
|
|
" chatId: 'test-chat',",
|
|
" };",
|
|
"}",
|
|
].join("\n");
|
|
|
|
const scriptShimSource = [
|
|
"export function getRequestHeaders() {",
|
|
" return {};",
|
|
"}",
|
|
"export function substituteParamsExtended(value) {",
|
|
" return String(value ?? '');",
|
|
"}",
|
|
].join("\n");
|
|
|
|
const openAiShimSource = [
|
|
"export const chat_completion_sources = {};",
|
|
"export async function sendOpenAIRequest() {",
|
|
" throw new Error('sendOpenAIRequest should not be called in extractor-split-pipeline test');",
|
|
"}",
|
|
].join("\n");
|
|
|
|
installResolveHooks([
|
|
{
|
|
specifiers: [
|
|
"../../../extensions.js",
|
|
"../../../../extensions.js",
|
|
"../../../../../extensions.js",
|
|
],
|
|
url: toDataModuleUrl(extensionsShimSource),
|
|
},
|
|
{
|
|
specifiers: [
|
|
"../../../../script.js",
|
|
"../../../../../script.js",
|
|
],
|
|
url: toDataModuleUrl(scriptShimSource),
|
|
},
|
|
{
|
|
specifiers: [
|
|
"../../../../openai.js",
|
|
"../../../../../openai.js",
|
|
],
|
|
url: toDataModuleUrl(openAiShimSource),
|
|
},
|
|
]);
|
|
|
|
const { createEmptyGraph, createNode, addNode } = await import("../graph/graph.js");
|
|
const { DEFAULT_NODE_SCHEMA } = await import("../graph/schema.js");
|
|
const { extractMemories } = await import("../maintenance/extractor.js");
|
|
const { defaultSettings } = await import("../runtime/settings-defaults.js");
|
|
|
|
function setTestOverrides(overrides = {}) {
|
|
globalThis.__stBmeTestOverrides = overrides;
|
|
return () => {
|
|
delete globalThis.__stBmeTestOverrides;
|
|
};
|
|
}
|
|
|
|
globalThis.__stBmeTestContext = {
|
|
chat: [],
|
|
chatMetadata: {},
|
|
extensionSettings: {},
|
|
powerUserSettings: {},
|
|
characters: {},
|
|
characterId: null,
|
|
name1: "玩家",
|
|
name2: "艾琳",
|
|
chatId: "test-chat",
|
|
};
|
|
|
|
function createGraphWithCharacter() {
|
|
const graph = createEmptyGraph();
|
|
addNode(
|
|
graph,
|
|
createNode({
|
|
type: "character",
|
|
fields: { name: "艾琳" },
|
|
seq: 1,
|
|
}),
|
|
);
|
|
return graph;
|
|
}
|
|
|
|
const baseExtractParams = {
|
|
messages: [
|
|
{ seq: 20, role: "user", content: "钟楼里传来第二次钟声。", name: "玩家", speaker: "玩家" },
|
|
{ seq: 21, role: "assistant", content: "艾琳记下钟声，怀疑暗道就在附近。", name: "艾琳", speaker: "艾琳" },
|
|
],
|
|
startSeq: 20,
|
|
endSeq: 21,
|
|
schema: DEFAULT_NODE_SCHEMA,
|
|
embeddingConfig: null,
|
|
};
|
|
|
|
function objectivePayload() {
|
|
return {
|
|
operations: [
|
|
{
|
|
action: "create",
|
|
type: "event",
|
|
ref: "evt-clock",
|
|
fields: {
|
|
title: "钟楼钟声",
|
|
summary: "钟楼传来第二次钟声，暗示暗道线索仍在附近。",
|
|
participants: "玩家,艾琳",
|
|
status: "ongoing",
|
|
},
|
|
scope: { layer: "objective" },
|
|
},
|
|
],
|
|
cognitionUpdates: [
|
|
{
|
|
ownerType: "character",
|
|
ownerName: "艾琳",
|
|
knownRefs: ["evt-clock"],
|
|
},
|
|
],
|
|
regionUpdates: {},
|
|
};
|
|
}
|
|
|
|
function subjectivePayload() {
|
|
return {
|
|
operations: [
|
|
{
|
|
action: "create",
|
|
type: "pov_memory",
|
|
fields: {
|
|
summary: "艾琳把第二次钟声记成暗道仍在呼唤她的证据。",
|
|
belief: "暗道就在钟楼附近",
|
|
emotion: "警觉",
|
|
certainty: "unsure",
|
|
about: "evt-clock",
|
|
},
|
|
scope: {
|
|
layer: "pov",
|
|
ownerType: "character",
|
|
ownerName: "艾琳",
|
|
ownerId: "艾琳",
|
|
},
|
|
},
|
|
],
|
|
cognitionUpdates: [
|
|
{
|
|
ownerType: "character",
|
|
ownerName: "艾琳",
|
|
knownRefs: ["evt-clock"],
|
|
},
|
|
],
|
|
regionUpdates: {},
|
|
};
|
|
}
|
|
|
|
function activeNodes(graph, type) {
|
|
return graph.nodes.filter((node) => node.type === type && node.archived !== true);
|
|
}
|
|
|
|
function hasActiveEdgeBetween(graph, leftId, rightId) {
|
|
return graph.edges.some((edge) => {
|
|
if (edge.invalidAt || edge.expiredAt) return false;
|
|
return (
|
|
(edge.fromId === leftId && edge.toId === rightId) ||
|
|
(edge.fromId === rightId && edge.toId === leftId)
|
|
);
|
|
});
|
|
}
|
|
|
|
function characterKnowledgeEntries(graph) {
|
|
return Object.values(graph.knowledgeState?.owners || {}).filter(
|
|
(entry) =>
|
|
String(entry?.ownerType || "") === "character" &&
|
|
String(entry?.ownerName || "") === "艾琳",
|
|
);
|
|
}
|
|
|
|
async function captureTaskTypesForExtract(settings, options = {}) {
|
|
const graph = createGraphWithCharacter();
|
|
const capturedTaskTypes = [];
|
|
const restore = setTestOverrides({
|
|
llm: {
|
|
async callLLMForJSON(payload = {}) {
|
|
capturedTaskTypes.push(payload.taskType);
|
|
if (payload.taskType === "extract_objective") return objectivePayload();
|
|
if (payload.taskType === "extract_subjective") return subjectivePayload();
|
|
if (payload.taskType === "extract") return { operations: [], cognitionUpdates: [], regionUpdates: {} };
|
|
return { operations: [], cognitionUpdates: [], regionUpdates: {} };
|
|
},
|
|
},
|
|
});
|
|
|
|
try {
|
|
const params = {
|
|
graph,
|
|
...baseExtractParams,
|
|
};
|
|
if (options.includeSettings !== false) {
|
|
params.settings = settings;
|
|
}
|
|
const result = await extractMemories(params);
|
|
return { graph, result, capturedTaskTypes };
|
|
} finally {
|
|
restore();
|
|
}
|
|
}
|
|
|
|
function cloneJson(value) {
|
|
return JSON.parse(JSON.stringify(value));
|
|
}
|
|
|
|
function createCustomizedLegacyExtractProfileSettings() {
|
|
const taskProfiles = cloneJson(defaultSettings.taskProfiles);
|
|
const baseProfile = taskProfiles.extract.profiles[0];
|
|
const customProfile = {
|
|
...baseProfile,
|
|
id: "custom-legacy-extract-profile",
|
|
name: "Custom legacy extract profile",
|
|
builtin: false,
|
|
blocks: (Array.isArray(baseProfile.blocks) ? baseProfile.blocks : []).map((block, index) =>
|
|
index === 0
|
|
? { ...block, content: `${String(block.content || "")}\nCUSTOM_LEGACY_EXTRACT_SENTINEL` }
|
|
: { ...block },
|
|
),
|
|
};
|
|
taskProfiles.extract = {
|
|
activeProfileId: customProfile.id,
|
|
profiles: [baseProfile, customProfile],
|
|
};
|
|
return {
|
|
...defaultSettings,
|
|
extractPipelineVersion: "split-v1",
|
|
taskProfiles,
|
|
};
|
|
}
|
|
|
|
function createDefaultExtractProfileSettings(mutator) {
|
|
const taskProfiles = cloneJson(defaultSettings.taskProfiles);
|
|
const extractProfiles = taskProfiles.extract.profiles || [];
|
|
const defaultProfile = extractProfiles.find((profile) => profile.id === "default") || extractProfiles[0];
|
|
mutator?.(defaultProfile, taskProfiles.extract);
|
|
return {
|
|
...defaultSettings,
|
|
extractPipelineVersion: "split-v1",
|
|
taskProfiles,
|
|
};
|
|
}
|
|
|
|
// Phase 4 default switch: omitting settings should use the split pipeline by default.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract(undefined, {
|
|
includeSettings: false,
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract_objective", "extract_subjective"],
|
|
"extractMemories without explicit settings should default to split objective+subjective extraction",
|
|
);
|
|
}
|
|
|
|
// Phase 4 default switch: the default settings object should request split-v1.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract({
|
|
...defaultSettings,
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.equal(defaultSettings.extractPipelineVersion, "split-v1");
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract_objective", "extract_subjective"],
|
|
"defaultSettings should call split objective+subjective extraction",
|
|
);
|
|
}
|
|
|
|
// split-v1 calls objective then subjective, merges both stage outputs, and commits once.
|
|
{
|
|
const graph = createGraphWithCharacter();
|
|
const capturedTaskTypes = [];
|
|
const restore = setTestOverrides({
|
|
llm: {
|
|
async callLLMForJSON(payload = {}) {
|
|
capturedTaskTypes.push(payload.taskType);
|
|
if (payload.taskType === "extract_objective") return objectivePayload();
|
|
if (payload.taskType === "extract_subjective") return subjectivePayload();
|
|
return { operations: [], cognitionUpdates: [], regionUpdates: {} };
|
|
},
|
|
},
|
|
});
|
|
|
|
try {
|
|
const result = await extractMemories({
|
|
graph,
|
|
...baseExtractParams,
|
|
settings: { extractPipelineVersion: "split-v1" },
|
|
});
|
|
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract_objective", "extract_subjective"],
|
|
"split-v1 should call the LLM once for objective extraction, then once for subjective extraction",
|
|
);
|
|
assert.equal(result.success, true);
|
|
assert.equal(result.newNodes, 2, "objective event and subjective POV memory should be committed together");
|
|
|
|
const [eventNode] = activeNodes(graph, "event");
|
|
const [povNode] = activeNodes(graph, "pov_memory");
|
|
assert.ok(eventNode, "objective event operation should be committed");
|
|
assert.ok(povNode, "subjective pov_memory operation should be committed");
|
|
assert.equal(povNode.scope?.ownerType, "character");
|
|
assert.equal(povNode.scope?.ownerName, "艾琳");
|
|
assert.equal(graph.lastProcessedSeq, 21);
|
|
assert.ok(
|
|
hasActiveEdgeBetween(graph, eventNode.id, povNode.id),
|
|
"merged split stages should be committed as one batch so default batch edges see both nodes",
|
|
);
|
|
|
|
const knowledgeEntry = characterKnowledgeEntries(graph).find((entry) =>
|
|
Array.isArray(entry.knownNodeIds) && entry.knownNodeIds.includes(eventNode.id),
|
|
);
|
|
assert.ok(
|
|
knowledgeEntry,
|
|
"subjective cognitionUpdates should apply through the merged ref map",
|
|
);
|
|
} finally {
|
|
restore();
|
|
}
|
|
}
|
|
|
|
// Invalid subjective output fails the split extraction before any objective-only commit mutates the graph.
|
|
{
|
|
const graph = createGraphWithCharacter();
|
|
const initialNodeCount = graph.nodes.length;
|
|
const initialEdgeCount = graph.edges.length;
|
|
const capturedTaskTypes = [];
|
|
const restore = setTestOverrides({
|
|
llm: {
|
|
async callLLMForJSON(payload = {}) {
|
|
capturedTaskTypes.push(payload.taskType);
|
|
if (payload.taskType === "extract_objective") return objectivePayload();
|
|
if (payload.taskType === "extract_subjective") return { thought: "missing operations" };
|
|
return { thought: "legacy path should not be used for split-v1" };
|
|
},
|
|
},
|
|
});
|
|
|
|
try {
|
|
const result = await extractMemories({
|
|
graph,
|
|
...baseExtractParams,
|
|
settings: { extractPipelineVersion: "split-v1" },
|
|
});
|
|
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract_objective", "extract_subjective"],
|
|
"split-v1 should validate both objective and subjective payloads before commit",
|
|
);
|
|
assert.equal(result.success, false);
|
|
assert.equal(graph.nodes.length, initialNodeCount, "invalid subjective payload should not commit objective nodes");
|
|
assert.equal(graph.edges.length, initialEdgeCount, "invalid subjective payload should not create edges");
|
|
assert.equal(graph.lastProcessedSeq ?? -1, -1, "invalid split extraction should not advance extraction progress");
|
|
} finally {
|
|
restore();
|
|
}
|
|
}
|
|
|
|
// Legacy guard: a non-empty legacy extractPrompt should force the single extract taskType path.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract({
|
|
...defaultSettings,
|
|
extractPipelineVersion: "split-v1",
|
|
extractPrompt: "CUSTOM LEGACY EXTRACT PROMPT",
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract"],
|
|
"non-empty extractPrompt should guard back to legacy taskType extract",
|
|
);
|
|
}
|
|
|
|
// Legacy guard: an active customized legacy extract task profile should force the single extract path.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract(
|
|
createCustomizedLegacyExtractProfileSettings(),
|
|
);
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(
|
|
capturedTaskTypes,
|
|
["extract"],
|
|
"customized active taskProfiles.extract profile should guard back to legacy taskType extract",
|
|
);
|
|
}
|
|
|
|
// Legacy guard: an explicit legacy override should always keep the single extract path.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract({
|
|
...defaultSettings,
|
|
extractPipelineVersion: "legacy-single",
|
|
});
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(capturedTaskTypes, ["extract"]);
|
|
}
|
|
|
|
// Legacy guard: migrated legacy default-looking profiles are conservative legacy.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract(
|
|
createDefaultExtractProfileSettings((profile) => {
|
|
profile.metadata = {
|
|
...(profile.metadata || {}),
|
|
migratedFromLegacy: true,
|
|
};
|
|
}),
|
|
);
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(capturedTaskTypes, ["extract"]);
|
|
}
|
|
|
|
// Legacy guard: stale default profile metadata is conservative legacy.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract(
|
|
createDefaultExtractProfileSettings((profile) => {
|
|
profile.metadata = {
|
|
...(profile.metadata || {}),
|
|
defaultTemplateFingerprint: "stale-fingerprint",
|
|
};
|
|
}),
|
|
);
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(capturedTaskTypes, ["extract"]);
|
|
}
|
|
|
|
// Legacy guard: modified default profile content is conservative legacy even if id/builtin remain default.
|
|
{
|
|
const { result, capturedTaskTypes } = await captureTaskTypesForExtract(
|
|
createDefaultExtractProfileSettings((profile) => {
|
|
profile.blocks = (profile.blocks || []).map((block, index) =>
|
|
index === 0
|
|
? { ...block, content: `${String(block.content || "")}
|
|
CUSTOM_DEFAULT_PROFILE_SENTINEL` }
|
|
: { ...block },
|
|
);
|
|
}),
|
|
);
|
|
|
|
assert.equal(result.success, true);
|
|
assert.deepEqual(capturedTaskTypes, ["extract"]);
|
|
}
|
|
|
|
console.log("extractor-split-pipeline tests passed");
|