mirror of
https://github.com/Youzini-afk/ST-Bionic-Memory-Ecology.git
synced 2026-06-14 02:40:45 +08:00
446 lines
15 KiB
JavaScript
446 lines
15 KiB
JavaScript
export function createRerollRecallInput(deps = {}) {
|
||
let pendingRerollRecallReuse = null;
|
||
const plannerRecallHandoffs = new Map();
|
||
|
||
const getContext = (...args) => deps.getContext?.(...args);
|
||
const getCurrentChatId = (...args) => deps.getCurrentChatId?.(...args);
|
||
const normalizeChatIdCandidate = (value = "") =>
|
||
deps.normalizeChatIdCandidate?.(value) ?? String(value ?? "").trim();
|
||
const normalizeRecallInputText = (value = "") =>
|
||
deps.normalizeRecallInputText?.(value) ?? String(value || "").trim();
|
||
const hashRecallInput = (value = "") => deps.hashRecallInput?.(value) ?? "";
|
||
const getLastRecallSentUserMessage = () =>
|
||
deps.getLastRecallSentUserMessage?.() || {};
|
||
const getPendingRecallSendIntent = () =>
|
||
deps.getPendingRecallSendIntent?.() || {};
|
||
const getGenerationRecallTransactionTtlMs = () =>
|
||
Number.isFinite(Number(deps.GENERATION_RECALL_TRANSACTION_TTL_MS))
|
||
? Number(deps.GENERATION_RECALL_TRANSACTION_TTL_MS)
|
||
: 60000;
|
||
const getPlannerRecallHandoffTtlMs = () =>
|
||
Number.isFinite(Number(deps.PLANNER_RECALL_HANDOFF_TTL_MS))
|
||
? Number(deps.PLANNER_RECALL_HANDOFF_TTL_MS)
|
||
: 60000;
|
||
|
||
function getPendingRerollRecallReuse() {
|
||
return pendingRerollRecallReuse;
|
||
}
|
||
|
||
function clearPendingRerollRecallReuse(reason = "") {
|
||
const previous = pendingRerollRecallReuse;
|
||
pendingRerollRecallReuse = null;
|
||
return previous;
|
||
}
|
||
|
||
function prepareRerollRecallReuse({ fromFloor = null, meta = null } = {}) {
|
||
const context = getContext();
|
||
const chat = context?.chat;
|
||
if (!Array.isArray(chat) || chat.length === 0) {
|
||
pendingRerollRecallReuse = null;
|
||
return null;
|
||
}
|
||
|
||
const latestUser = deps.findLatestUserChatMessageWithIndex(chat);
|
||
const targetUserMessageIndex = Number.isFinite(latestUser?.index)
|
||
? latestUser.index
|
||
: null;
|
||
if (!Number.isFinite(targetUserMessageIndex)) {
|
||
pendingRerollRecallReuse = null;
|
||
return null;
|
||
}
|
||
|
||
const userMessage = chat[targetUserMessageIndex];
|
||
const userText = normalizeRecallInputText(userMessage?.mes || "");
|
||
if (!userText) {
|
||
pendingRerollRecallReuse = null;
|
||
return null;
|
||
}
|
||
|
||
const persistedRecord = deps.readPersistedRecallFromUserMessage(
|
||
chat,
|
||
targetUserMessageIndex,
|
||
);
|
||
const chatId = normalizeChatIdCandidate(getCurrentChatId(context));
|
||
const prepared = deps.createRerollRecallReuseMarker({
|
||
chatId,
|
||
fromFloor,
|
||
targetUserMessageIndex,
|
||
userText,
|
||
persistedRecord,
|
||
hashRecallInput,
|
||
now: Date.now(),
|
||
meta,
|
||
});
|
||
if (!prepared.marker) {
|
||
pendingRerollRecallReuse = null;
|
||
return null;
|
||
}
|
||
|
||
pendingRerollRecallReuse = prepared.marker;
|
||
return pendingRerollRecallReuse;
|
||
}
|
||
|
||
function consumePendingRerollRecallReuse(chat = getContext()?.chat) {
|
||
const reuse = pendingRerollRecallReuse;
|
||
if (!reuse) return null;
|
||
|
||
const activeChatId = normalizeChatIdCandidate(getCurrentChatId());
|
||
const latestUser = deps.findLatestUserChatMessageWithIndex(chat);
|
||
const targetUserMessageIndex = Number.isFinite(latestUser?.index)
|
||
? latestUser.index
|
||
: reuse.targetUserMessageIndex;
|
||
const userText = normalizeRecallInputText(chat?.[targetUserMessageIndex]?.mes || "");
|
||
const consumed = deps.consumeRerollRecallReuseMarker({
|
||
marker: reuse,
|
||
activeChatId,
|
||
latestUserMessageIndex: targetUserMessageIndex,
|
||
currentUserText: userText,
|
||
hashRecallInput,
|
||
now: Date.now(),
|
||
ttlMs: getGenerationRecallTransactionTtlMs(),
|
||
});
|
||
pendingRerollRecallReuse = consumed.marker;
|
||
return consumed.consumed ? consumed.override : null;
|
||
}
|
||
|
||
function buildGenerationAfterCommandsRecallInput(type, params = {}, chat) {
|
||
if (params?.automatic_trigger || params?.quiet_prompt) {
|
||
return null;
|
||
}
|
||
|
||
const generationType = String(type || "").trim() || "normal";
|
||
if (!["normal", "continue", "regenerate", "swipe"].includes(generationType)) {
|
||
return null;
|
||
}
|
||
|
||
const targetUserMessageIndex = deps.resolveGenerationTargetUserMessageIndex(chat, {
|
||
generationType,
|
||
});
|
||
|
||
// 对于 history 类型（continue/regenerate/swipe），必须依赖 chat 中的用户消息
|
||
if (generationType !== "normal") {
|
||
if (!Number.isFinite(targetUserMessageIndex)) {
|
||
return {
|
||
generationType,
|
||
targetUserMessageIndex: null,
|
||
};
|
||
}
|
||
const historyInput = buildHistoryGenerationRecallInput(chat);
|
||
if (!historyInput) {
|
||
return {
|
||
generationType,
|
||
targetUserMessageIndex,
|
||
};
|
||
}
|
||
return {
|
||
...historyInput,
|
||
generationType,
|
||
targetUserMessageIndex,
|
||
};
|
||
}
|
||
|
||
// 对于 normal 类型：GENERATION_AFTER_COMMANDS 触发时用户消息可能不在 chat 末尾
|
||
// （ST 可能已追加空 assistant 消息）。如果 chat 中存在任何用户消息，
|
||
// 继续走 buildNormalGenerationRecallInput，它会通过 latestUserText 兜底找到。
|
||
// 如果 chat 中完全没有用户消息，则延迟到 BEFORE_COMBINE_PROMPTS 处理。
|
||
if (!Number.isFinite(targetUserMessageIndex) && !deps.getLatestUserChatMessage(chat)) {
|
||
return {
|
||
generationType,
|
||
targetUserMessageIndex: null,
|
||
};
|
||
}
|
||
|
||
const normalInput = buildNormalGenerationRecallInput(chat, {
|
||
frozenInputSnapshot: params?.frozenInputSnapshot,
|
||
});
|
||
return normalInput;
|
||
}
|
||
|
||
function buildNormalGenerationRecallInput(chat, options = {}) {
|
||
const rerollReuse = consumePendingRerollRecallReuse(chat);
|
||
if (rerollReuse) {
|
||
return rerollReuse;
|
||
}
|
||
|
||
const lastNonSystemMessage = deps.getLastNonSystemChatMessage(chat);
|
||
const tailUserText = lastNonSystemMessage?.is_user
|
||
? normalizeRecallInputText(lastNonSystemMessage?.mes || "")
|
||
: "";
|
||
// 当 GENERATION_AFTER_COMMANDS 触发时，ST 可能已追加了空 assistant 消息。
|
||
// 导致 lastNonSystemMessage 不是 user。用 getLatestUserChatMessage 反向扫描
|
||
// 定位真正的用户消息（与 shujuku 参考实现一致）。
|
||
const latestUserMessage = !tailUserText ? deps.getLatestUserChatMessage(chat) : null;
|
||
const latestUserText = latestUserMessage
|
||
? normalizeRecallInputText(latestUserMessage?.mes || "")
|
||
: "";
|
||
const targetUserMessageIndex = deps.resolveGenerationTargetUserMessageIndex(chat, {
|
||
generationType: "normal",
|
||
});
|
||
const frozenInputSnapshot = deps.isFreshRecallInputRecord(
|
||
options?.frozenInputSnapshot,
|
||
)
|
||
? options.frozenInputSnapshot
|
||
: null;
|
||
const pendingRecallSendIntent = getPendingRecallSendIntent();
|
||
const pendingSendIntent = deps.isFreshRecallInputRecord(pendingRecallSendIntent)
|
||
? pendingRecallSendIntent
|
||
: null;
|
||
const sendIntentText = normalizeRecallInputText(
|
||
pendingSendIntent?.text || "",
|
||
);
|
||
const hostSnapshotText = normalizeRecallInputText(
|
||
frozenInputSnapshot?.text || "",
|
||
);
|
||
const textareaText = normalizeRecallInputText(deps.getSendTextareaValue());
|
||
const sourceCandidates = [
|
||
sendIntentText
|
||
? {
|
||
text: sendIntentText,
|
||
source: "send-intent",
|
||
sourceLabel: "发送意图",
|
||
reason: tailUserText
|
||
? "send-intent-overrides-chat-tail"
|
||
: "send-intent-captured",
|
||
includeSyntheticUserMessage: !tailUserText,
|
||
}
|
||
: null,
|
||
hostSnapshotText
|
||
? {
|
||
text: hostSnapshotText,
|
||
source: String(
|
||
frozenInputSnapshot?.source || "host-generation-lifecycle",
|
||
),
|
||
sourceLabel: "宿主发送快照",
|
||
reason: sendIntentText
|
||
? "host-snapshot-suppressed-by-send-intent"
|
||
: tailUserText
|
||
? "host-snapshot-suppressed-by-chat-tail"
|
||
: "host-snapshot-captured",
|
||
includeSyntheticUserMessage: !tailUserText,
|
||
}
|
||
: null,
|
||
tailUserText
|
||
? {
|
||
text: tailUserText,
|
||
source: "chat-tail-user",
|
||
sourceLabel: "当前用户楼层",
|
||
reason:
|
||
sendIntentText || hostSnapshotText
|
||
? "chat-tail-deprioritized"
|
||
: "chat-tail-fallback",
|
||
includeSyntheticUserMessage: false,
|
||
}
|
||
: null,
|
||
latestUserText
|
||
? {
|
||
text: latestUserText,
|
||
source: "chat-latest-user",
|
||
sourceLabel: "最近用户消息",
|
||
reason:
|
||
sendIntentText || hostSnapshotText || tailUserText
|
||
? "latest-user-deprioritized"
|
||
: "latest-user-fallback",
|
||
includeSyntheticUserMessage: false,
|
||
}
|
||
: null,
|
||
textareaText
|
||
? {
|
||
text: textareaText,
|
||
source: "textarea-live",
|
||
sourceLabel: "输入框当前文本",
|
||
reason:
|
||
sendIntentText || hostSnapshotText || tailUserText
|
||
? "textarea-live-deprioritized"
|
||
: "textarea-live-fallback",
|
||
includeSyntheticUserMessage: !tailUserText,
|
||
}
|
||
: null,
|
||
].filter(Boolean);
|
||
const activeTrivialSkip = deps.getCurrentGenerationTrivialSkip();
|
||
if (activeTrivialSkip) {
|
||
deps.clearPendingRecallSendIntent();
|
||
deps.clearPendingHostGenerationInputSnapshot();
|
||
return deps.createTrivialRecallSkipSentinel(activeTrivialSkip.reason);
|
||
}
|
||
|
||
const selectedCandidate = sourceCandidates[0] || null;
|
||
if (!selectedCandidate?.text) return null;
|
||
|
||
const trivialInputResult = deps.isTrivialUserInput(selectedCandidate.text);
|
||
|
||
if (trivialInputResult.trivial) {
|
||
deps.clearPendingRecallSendIntent();
|
||
deps.clearPendingHostGenerationInputSnapshot();
|
||
deps.markCurrentGenerationTrivialSkip({
|
||
reason: trivialInputResult.reason,
|
||
chatId: getCurrentChatId(),
|
||
chatLength: Array.isArray(chat) ? chat.length : 0,
|
||
});
|
||
deps.console?.info?.(
|
||
`[ST-BME] trivial-input skip: reason=${trivialInputResult.reason} len=${trivialInputResult.normalizedText.length} hook=build-normal-input`,
|
||
);
|
||
return deps.createTrivialRecallSkipSentinel(trivialInputResult.reason);
|
||
}
|
||
|
||
return {
|
||
overrideUserMessage: selectedCandidate.text,
|
||
generationType: "normal",
|
||
targetUserMessageIndex,
|
||
overrideSource: selectedCandidate.source,
|
||
overrideSourceLabel: selectedCandidate.sourceLabel,
|
||
overrideReason: selectedCandidate.reason,
|
||
sourceCandidates,
|
||
includeSyntheticUserMessage: selectedCandidate.includeSyntheticUserMessage,
|
||
};
|
||
}
|
||
|
||
function buildHistoryGenerationRecallInput(chat) {
|
||
const lastRecallSentUserMessage = getLastRecallSentUserMessage();
|
||
const latestUserText = normalizeRecallInputText(
|
||
deps.getLatestUserChatMessage(chat)?.mes || lastRecallSentUserMessage.text,
|
||
);
|
||
if (!latestUserText) return null;
|
||
const targetUserMessageIndex = deps.resolveGenerationTargetUserMessageIndex(chat, {
|
||
generationType: "history",
|
||
});
|
||
|
||
return {
|
||
overrideUserMessage: latestUserText,
|
||
generationType: "history",
|
||
targetUserMessageIndex,
|
||
overrideSource: Number.isFinite(targetUserMessageIndex)
|
||
? "chat-last-user"
|
||
: "chat-last-user-missing",
|
||
overrideSourceLabel: Number.isFinite(targetUserMessageIndex)
|
||
? "历史最后用户楼层"
|
||
: "历史用户楼层缺失",
|
||
includeSyntheticUserMessage: false,
|
||
};
|
||
}
|
||
|
||
function cleanupPlannerRecallHandoffs(now = Date.now()) {
|
||
for (const [chatId, handoff] of plannerRecallHandoffs.entries()) {
|
||
if (
|
||
!handoff ||
|
||
String(handoff.chatId || "") !== String(chatId || "") ||
|
||
now - Number(handoff.updatedAt || handoff.createdAt || 0) >
|
||
getPlannerRecallHandoffTtlMs()
|
||
) {
|
||
plannerRecallHandoffs.delete(chatId);
|
||
}
|
||
}
|
||
}
|
||
|
||
function peekPlannerRecallHandoff(
|
||
chatId = getCurrentChatId(),
|
||
now = Date.now(),
|
||
) {
|
||
cleanupPlannerRecallHandoffs(now);
|
||
const normalizedChatId = normalizeChatIdCandidate(chatId);
|
||
if (!normalizedChatId) return null;
|
||
|
||
const handoff = plannerRecallHandoffs.get(normalizedChatId) || null;
|
||
if (!handoff) return null;
|
||
if (
|
||
now - Number(handoff.updatedAt || handoff.createdAt || 0) >
|
||
getPlannerRecallHandoffTtlMs()
|
||
) {
|
||
plannerRecallHandoffs.delete(normalizedChatId);
|
||
return null;
|
||
}
|
||
return handoff;
|
||
}
|
||
|
||
function clearPlannerRecallHandoffsForChat(
|
||
chatId = getCurrentChatId(),
|
||
{ clearAll = false } = {},
|
||
) {
|
||
cleanupPlannerRecallHandoffs();
|
||
if (clearAll) {
|
||
const removed = plannerRecallHandoffs.size;
|
||
plannerRecallHandoffs.clear();
|
||
return removed;
|
||
}
|
||
|
||
const normalizedChatId = normalizeChatIdCandidate(chatId);
|
||
if (!normalizedChatId) return 0;
|
||
return plannerRecallHandoffs.delete(normalizedChatId) ? 1 : 0;
|
||
}
|
||
|
||
function consumePlannerRecallHandoff(
|
||
chatId = getCurrentChatId(),
|
||
{ handoffId = "" } = {},
|
||
) {
|
||
const normalizedChatId = normalizeChatIdCandidate(chatId);
|
||
if (!normalizedChatId) return null;
|
||
|
||
const handoff = peekPlannerRecallHandoff(normalizedChatId);
|
||
if (!handoff) return null;
|
||
if (handoffId && String(handoff.id || "") !== String(handoffId || "")) {
|
||
return null;
|
||
}
|
||
|
||
plannerRecallHandoffs.delete(normalizedChatId);
|
||
return handoff;
|
||
}
|
||
|
||
function preparePlannerRecallHandoff({
|
||
rawUserInput = "",
|
||
plannerAugmentedMessage = "",
|
||
plannerRecall = null,
|
||
chatId = getCurrentChatId(),
|
||
} = {}) {
|
||
const normalizedChatId = normalizeChatIdCandidate(chatId);
|
||
const normalizedRawUserInput = normalizeRecallInputText(rawUserInput);
|
||
const normalizedPlannerAugmentedMessage = normalizeRecallInputText(
|
||
plannerAugmentedMessage,
|
||
);
|
||
const result = plannerRecall?.result || null;
|
||
if (!normalizedChatId || !normalizedRawUserInput || !result) {
|
||
return null;
|
||
}
|
||
|
||
cleanupPlannerRecallHandoffs();
|
||
const createdAt = Date.now();
|
||
const injectionText = normalizeRecallInputText(
|
||
plannerRecall?.memoryBlock || deps.formatInjection(result, deps.getSchema()),
|
||
);
|
||
const handoff = {
|
||
id: [
|
||
normalizedChatId,
|
||
hashRecallInput(normalizedRawUserInput),
|
||
createdAt,
|
||
].join(":"),
|
||
chatId: normalizedChatId,
|
||
rawUserInput: normalizedRawUserInput,
|
||
plannerAugmentedMessage: normalizedPlannerAugmentedMessage,
|
||
result,
|
||
recentMessages: Array.isArray(plannerRecall?.recentMessages)
|
||
? plannerRecall.recentMessages.map((item) => String(item || ""))
|
||
: [],
|
||
injectionText,
|
||
source: "planner-handoff",
|
||
sourceLabel: "Planner handoff",
|
||
createdAt,
|
||
updatedAt: createdAt,
|
||
};
|
||
plannerRecallHandoffs.set(normalizedChatId, handoff);
|
||
return handoff;
|
||
}
|
||
|
||
return {
|
||
prepareRerollRecallReuse,
|
||
getPendingRerollRecallReuse,
|
||
clearPendingRerollRecallReuse,
|
||
consumePendingRerollRecallReuse,
|
||
buildNormalGenerationRecallInput,
|
||
buildHistoryGenerationRecallInput,
|
||
buildGenerationAfterCommandsRecallInput,
|
||
preparePlannerRecallHandoff,
|
||
cleanupPlannerRecallHandoffs,
|
||
peekPlannerRecallHandoff,
|
||
clearPlannerRecallHandoffsForChat,
|
||
consumePlannerRecallHandoff,
|
||
};
|
||
}
|