fix stuff and make some changes to overall AI logic
This commit is contained in:
+252
-147
@@ -18,7 +18,12 @@ import {
|
||||
} from "./chatMessageHelpers.js";
|
||||
|
||||
export function createChatService(repositories, modelService, config) {
|
||||
const insertChatMessage = (chatId, role, content, retryState = null, modelName = null) => {
|
||||
const chatGenerationQueues = new Map();
|
||||
const summaryQueues = new Map();
|
||||
const activeGenerations = new Map();
|
||||
const maxRetries = Number(config.chatMaxRetries ?? 5);
|
||||
|
||||
const insertChatMessage = (chatId, role, content, retryState = null, modelName = null, deliveryStatus = "complete", errorMessage = null) => {
|
||||
const normalizedContent = String(content || "");
|
||||
const payload = retryState
|
||||
? {
|
||||
@@ -33,9 +38,41 @@ export function createChatService(repositories, modelService, config) {
|
||||
retryRetriesUsed: 0,
|
||||
retryPromptMessageId: null
|
||||
};
|
||||
repositories.insertChatMessage(chatId, role, normalizedContent, payload, modelName);
|
||||
return repositories.insertChatMessage(chatId, role, normalizedContent, payload, modelName, deliveryStatus, errorMessage);
|
||||
};
|
||||
|
||||
const withChatGenerationLock = (chatId, operation) => {
|
||||
const previous = chatGenerationQueues.get(chatId) || Promise.resolve();
|
||||
const current = previous.catch(() => undefined).then(operation);
|
||||
chatGenerationQueues.set(chatId, current);
|
||||
return current.finally(() => {
|
||||
if (chatGenerationQueues.get(chatId) === current) chatGenerationQueues.delete(chatId);
|
||||
});
|
||||
};
|
||||
|
||||
const withActiveGeneration = async (chatId, externalSignal, operation) => {
|
||||
const controller = new AbortController();
|
||||
const abortFromCaller = () => controller.abort(externalSignal?.reason);
|
||||
if (externalSignal?.aborted) abortFromCaller();
|
||||
else externalSignal?.addEventListener("abort", abortFromCaller, {once: true});
|
||||
activeGenerations.set(chatId, controller);
|
||||
try {
|
||||
return await operation(controller.signal);
|
||||
} finally {
|
||||
if (activeGenerations.get(chatId) === controller) activeGenerations.delete(chatId);
|
||||
externalSignal?.removeEventListener("abort", abortFromCaller);
|
||||
}
|
||||
};
|
||||
|
||||
const getGenerationSettings = (session, requestedModel) => ({
|
||||
model: session.preferred_model || requestedModel || "mistral:latest",
|
||||
generation: {
|
||||
temperature: session.temperature ?? undefined,
|
||||
contextLength: session.context_length ?? undefined,
|
||||
responseLength: session.response_length ?? undefined
|
||||
}
|
||||
});
|
||||
|
||||
const persistChatMessageRetryState = ({chatId, messageId, content, retryVariants, retryActiveIndex, retryRetriesUsed, retryPromptMessageId}) => {
|
||||
repositories.updateChatMessageRetryState(chatId, messageId, {
|
||||
content,
|
||||
@@ -62,7 +99,8 @@ export function createChatService(repositories, modelService, config) {
|
||||
if (config.chatSummaryUpdateEveryMessages <= 0) return;
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return;
|
||||
const allMessages = repositories.listChatMessages(chatId);
|
||||
const allMessages = repositories.listActiveBranchMessages(chatId)
|
||||
.filter((message) => !message.delivery_status || message.delivery_status === "complete");
|
||||
const keepRecent = Math.max(0, config.chatHistoryLimit);
|
||||
const cutoffIndex = allMessages.length - keepRecent - 1;
|
||||
if (cutoffIndex < 0) return;
|
||||
@@ -106,6 +144,17 @@ export function createChatService(repositories, modelService, config) {
|
||||
}
|
||||
};
|
||||
|
||||
const scheduleContextSummaryUpdate = ({user, chatId, selectedModel}) => {
|
||||
const previous = summaryQueues.get(chatId) || Promise.resolve();
|
||||
const current = previous
|
||||
.catch(() => undefined)
|
||||
.then(() => updateContextSummaryWithoutBreakingReply({user, chatId, selectedModel}));
|
||||
summaryQueues.set(chatId, current);
|
||||
void current.finally(() => {
|
||||
if (summaryQueues.get(chatId) === current) summaryQueues.delete(chatId);
|
||||
});
|
||||
};
|
||||
|
||||
const getOrCreatePersonaChat = (user, persona, userPersonaId = null, scenarioPrompt = null, scenarioSummary = null) => {
|
||||
const existing = repositories.getChatByParticipants(user, persona.id, userPersonaId);
|
||||
if (existing) return existing;
|
||||
@@ -138,8 +187,8 @@ export function createChatService(repositories, modelService, config) {
|
||||
]);
|
||||
};
|
||||
|
||||
const generateValidatedRoleplayReply = async ({selectedModel, messagesPayload, userPersona}) => {
|
||||
let reply = await modelService.generateReply(selectedModel, messagesPayload);
|
||||
const generateValidatedRoleplayReply = async ({selectedModel, messagesPayload, userPersona, signal = null, generation = {}}) => {
|
||||
let reply = await modelService.generateReply(selectedModel, messagesPayload, {signal, generation});
|
||||
if (reply && !containsUserVoiceInRoleplayOpener(reply, userPersona)) {
|
||||
return reply;
|
||||
}
|
||||
@@ -151,7 +200,7 @@ export function createChatService(repositories, modelService, config) {
|
||||
role: "user",
|
||||
content: "Rewrite your last reply. Hard rule: only the assistant character may speak or act. Never write or imply user speech, thoughts, feelings, reactions, decisions, or actions. Stop before the user's reply."
|
||||
}
|
||||
]);
|
||||
], {signal, generation});
|
||||
|
||||
if (!reply || containsUserVoiceInRoleplayOpener(reply, userPersona)) {
|
||||
return null;
|
||||
@@ -164,12 +213,61 @@ export function createChatService(repositories, modelService, config) {
|
||||
return [...messagesPayload, {role: "user", content: retryStylePrompts[retryStyle]}];
|
||||
};
|
||||
|
||||
const buildRetryPayload = async ({chatId, user, session, selectedModel, targetMessage, retryStyle = null}) => {
|
||||
const getUserPersonaForSession = (chatId, user, session, activePersona) => {
|
||||
const chatPersona = repositories.getUserPersonaForChat(chatId, user);
|
||||
if (chatPersona || activePersona) return chatPersona || null;
|
||||
return repositories.getActiveUserPersona(user);
|
||||
};
|
||||
|
||||
const buildConversationContext = ({user, chatId, session = null, message, upToMessageId = null}) => {
|
||||
const activeSession = session || repositories.getChat(chatId, user);
|
||||
if (!activeSession) return null;
|
||||
const activePersona = repositories.getAssistantPersonaForChat(chatId, user);
|
||||
const activeUserPersona = repositories.getUserPersonaForChat(chatId, user) || repositories.getActiveUserPersona(user);
|
||||
const promptMessage = repositories.getPreviousUserMessage(chatId, targetMessage.id);
|
||||
const activeUserPersona = getUserPersonaForSession(chatId, user, activeSession, activePersona);
|
||||
const history = upToMessageId == null
|
||||
? repositories.getRecentChatMessages(chatId).reverse()
|
||||
: repositories.getRecentChatMessagesUpToId(chatId, upToMessageId).reverse();
|
||||
const conversation = message == null ? history : [...history, {role: "user", content: message}];
|
||||
const messagesPayload = [];
|
||||
if (activeSession.system_instruction) {
|
||||
messagesPayload.push({role: "system", content: `CHAT-SPECIFIC INSTRUCTIONS:\n${activeSession.system_instruction}`});
|
||||
}
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildPersonaPrompt(activePersona)});
|
||||
if (activeUserPersona) messagesPayload.push({role: "system", content: buildUserPersonaPrompt(activeUserPersona)});
|
||||
if (activePersona && activeSession.scenario_summary) {
|
||||
messagesPayload.push({
|
||||
role: "system",
|
||||
content: buildRoleplayDirectionPrompt({
|
||||
assistantPersona: activePersona,
|
||||
userPersona: activeUserPersona,
|
||||
scenarioPrompt: activeSession.scenario_prompt,
|
||||
sceneSummary: activeSession.scenario_summary
|
||||
})
|
||||
});
|
||||
}
|
||||
const contextSummaryPrompt = buildContextSummaryPrompt(upToMessageId == null ? activeSession.context_summary : null);
|
||||
if (contextSummaryPrompt) messagesPayload.push({role: "system", content: contextSummaryPrompt});
|
||||
const memoryPrompt = buildMemoryPrompt(repositories.listChatMemories(chatId, user));
|
||||
if (memoryPrompt) messagesPayload.push({role: "system", content: memoryPrompt});
|
||||
const personaStatePrompt = buildPersonaStatePrompt(repositories.getPersonaChatState(chatId, user));
|
||||
if (personaStatePrompt) messagesPayload.push({role: "system", content: personaStatePrompt});
|
||||
messagesPayload.push(...conversation.map((entry) => ({
|
||||
role: entry.role === "bot" ? "assistant" : "user",
|
||||
content: entry.content
|
||||
})));
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildRoleplayReplyGuardPrompt()});
|
||||
return {session: activeSession, activePersona, activeUserPersona, messagesPayload};
|
||||
};
|
||||
|
||||
const buildRetryPayload = async ({chatId, user, session, selectedModel, targetMessage, retryStyle = null, signal = null, generation = {}}) => {
|
||||
const parentMessage = targetMessage.parent_message_id
|
||||
? repositories.getChatMessage(chatId, targetMessage.parent_message_id)
|
||||
: null;
|
||||
const promptMessage = parentMessage?.role === "user"
|
||||
? parentMessage
|
||||
: repositories.getPreviousUserMessage(chatId, targetMessage.id);
|
||||
const activePersona = repositories.getAssistantPersonaForChat(chatId, user);
|
||||
const activeUserPersona = getUserPersonaForSession(chatId, user, session, activePersona);
|
||||
|
||||
if (!promptMessage) {
|
||||
if (!activePersona || !session.scenario_summary) {
|
||||
@@ -188,40 +286,92 @@ export function createChatService(repositories, modelService, config) {
|
||||
return {fullReply: opener, promptMessageId: null};
|
||||
}
|
||||
|
||||
const conversation = repositories.getRecentChatMessagesUpToId(chatId, promptMessage.id).reverse();
|
||||
const messagesPayload = [];
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildPersonaPrompt(activePersona)});
|
||||
if (activeUserPersona) messagesPayload.push({role: "system", content: buildUserPersonaPrompt(activeUserPersona)});
|
||||
if (activePersona && session.scenario_summary) {
|
||||
messagesPayload.push({
|
||||
role: "system",
|
||||
content: buildRoleplayDirectionPrompt({
|
||||
assistantPersona: activePersona,
|
||||
userPersona: activeUserPersona,
|
||||
scenarioPrompt: session.scenario_prompt,
|
||||
sceneSummary: session.scenario_summary
|
||||
})
|
||||
});
|
||||
}
|
||||
const contextSummaryPrompt = buildContextSummaryPrompt(session.context_summary);
|
||||
if (contextSummaryPrompt) messagesPayload.push({role: "system", content: contextSummaryPrompt});
|
||||
if (memoryPrompt) messagesPayload.push({role: "system", content: memoryPrompt});
|
||||
if (personaStatePrompt) messagesPayload.push({role: "system", content: personaStatePrompt});
|
||||
messagesPayload.push(...conversation.map((message) => ({
|
||||
role: message.role === "bot" ? "assistant" : "user",
|
||||
content: message.content
|
||||
})));
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildRoleplayReplyGuardPrompt()});
|
||||
const {messagesPayload} = buildConversationContext({
|
||||
user,
|
||||
chatId,
|
||||
session,
|
||||
message: null,
|
||||
upToMessageId: promptMessage.id
|
||||
});
|
||||
|
||||
const styledPayload = appendRetryStyleInstruction(messagesPayload, retryStyle);
|
||||
const fullReply = activePersona
|
||||
? await generateValidatedRoleplayReply({selectedModel, messagesPayload: styledPayload, userPersona: activeUserPersona})
|
||||
: await modelService.generateReply(selectedModel, styledPayload);
|
||||
? await generateValidatedRoleplayReply({selectedModel, messagesPayload: styledPayload, userPersona: activeUserPersona, signal, generation})
|
||||
: await modelService.generateReply(selectedModel, styledPayload, {signal, generation});
|
||||
|
||||
if (!fullReply) return {error: "Failed to regenerate message"};
|
||||
return {fullReply, promptMessageId: promptMessage.id};
|
||||
};
|
||||
|
||||
const generateChatTurn = ({user, chatId, message, model, onChunk = null, signal = null, parentMessageId = undefined}) =>
|
||||
withChatGenerationLock(chatId, async () => {
|
||||
await (summaryQueues.get(chatId) || Promise.resolve());
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return {error: "Chat not found", status: 404};
|
||||
if (parentMessageId !== undefined) {
|
||||
repositories.updateChatContextSummary(chatId, user, null, 0);
|
||||
session.context_summary = null;
|
||||
session.context_summary_message_id = 0;
|
||||
}
|
||||
const effectiveParentId = parentMessageId === undefined
|
||||
? session.active_leaf_message_id ?? repositories.getLatestChatMessage(chatId)?.id ?? null
|
||||
: parentMessageId;
|
||||
if (effectiveParentId != null && !repositories.getChatMessage(chatId, effectiveParentId)) {
|
||||
return {error: "Branch point not found", status: 404};
|
||||
}
|
||||
const {model: effectiveModel, generation} = getGenerationSettings(session, model);
|
||||
const inserted = repositories.insertBranchChatMessage(chatId, "user", message, null, null, "pending", null, effectiveParentId);
|
||||
const userMessageId = Number(inserted?.lastInsertRowid);
|
||||
try {
|
||||
const payload = buildConversationContext({user, chatId, session, message: null});
|
||||
const fullReply = await withActiveGeneration(chatId, signal, (activeSignal) => payload.activePersona
|
||||
? generateValidatedRoleplayReply({
|
||||
selectedModel: effectiveModel,
|
||||
messagesPayload: payload.messagesPayload,
|
||||
userPersona: payload.activeUserPersona,
|
||||
signal: activeSignal,
|
||||
generation
|
||||
})
|
||||
: onChunk
|
||||
? modelService.streamReply(effectiveModel, payload.messagesPayload, onChunk, {signal: activeSignal, generation})
|
||||
: modelService.generateReply(effectiveModel, payload.messagesPayload, {signal: activeSignal, generation}));
|
||||
|
||||
if (!fullReply) {
|
||||
repositories.failChatTurn(chatId, userMessageId, "Failed to generate a valid character reply", effectiveParentId);
|
||||
return {error: "Failed to generate a valid character reply", status: 500};
|
||||
}
|
||||
if (payload.activePersona && onChunk) onChunk(fullReply, fullReply);
|
||||
|
||||
const retryState = {
|
||||
retryVariants: [fullReply],
|
||||
retryActiveIndex: 0,
|
||||
retryRetriesUsed: 0,
|
||||
retryPromptMessageId: null
|
||||
};
|
||||
repositories.completeChatTurn(chatId, userMessageId, fullReply, retryState, effectiveModel);
|
||||
repositories.touchChat(chatId, user);
|
||||
scheduleContextSummaryUpdate({user, chatId, selectedModel: effectiveModel});
|
||||
return {reply: fullReply, userMessageId};
|
||||
} catch (error) {
|
||||
repositories.failChatTurn(chatId, userMessageId, String(error?.message || "Model request failed").slice(0, 500), effectiveParentId);
|
||||
repositories.touchChat(chatId, user);
|
||||
throw error;
|
||||
}
|
||||
});
|
||||
|
||||
const listActiveBranchMessages = (chatId) => repositories.listActiveBranchMessages(chatId).map((row) => {
|
||||
const message = formatChatMessage(row);
|
||||
const siblings = repositories.listSiblingChatMessages(chatId, row.role, row.parent_message_id);
|
||||
const siblingIndex = siblings.findIndex((sibling) => sibling.id === row.id);
|
||||
return {
|
||||
...message,
|
||||
siblingIndex,
|
||||
siblingCount: siblings.length,
|
||||
previousSiblingId: siblingIndex > 0 ? siblings[siblingIndex - 1].id : null,
|
||||
nextSiblingId: siblingIndex >= 0 && siblingIndex < siblings.length - 1 ? siblings[siblingIndex + 1].id : null
|
||||
};
|
||||
});
|
||||
|
||||
return {
|
||||
formatChatMessage,
|
||||
getChatMessageByIndex,
|
||||
@@ -231,124 +381,79 @@ export function createChatService(repositories, modelService, config) {
|
||||
insertChatMessage,
|
||||
containsUserVoiceInRoleplayOpener,
|
||||
persistChatMessageRetryState,
|
||||
buildMessagesPayload({user, chatId, message}) {
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return null;
|
||||
const activePersona = repositories.getAssistantPersonaForChat(chatId, user);
|
||||
const activeUserPersona = repositories.getUserPersonaForChat(chatId, user) || repositories.getActiveUserPersona(user);
|
||||
const history = repositories.getRecentChatMessages(chatId).reverse();
|
||||
const conversation = [...history, {role: "user", content: message}];
|
||||
const messagesPayload = [];
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildPersonaPrompt(activePersona)});
|
||||
if (activeUserPersona) messagesPayload.push({role: "system", content: buildUserPersonaPrompt(activeUserPersona)});
|
||||
if (activePersona && session.scenario_summary) {
|
||||
messagesPayload.push({
|
||||
role: "system",
|
||||
content: buildRoleplayDirectionPrompt({
|
||||
assistantPersona: activePersona,
|
||||
userPersona: activeUserPersona,
|
||||
scenarioPrompt: session.scenario_prompt,
|
||||
sceneSummary: session.scenario_summary
|
||||
})
|
||||
});
|
||||
}
|
||||
const contextSummaryPrompt = buildContextSummaryPrompt(session.context_summary);
|
||||
if (contextSummaryPrompt) messagesPayload.push({role: "system", content: contextSummaryPrompt});
|
||||
const memoryPrompt = buildMemoryPrompt(repositories.listChatMemories(chatId, user));
|
||||
if (memoryPrompt) messagesPayload.push({role: "system", content: memoryPrompt});
|
||||
const personaStatePrompt = buildPersonaStatePrompt(repositories.getPersonaChatState(chatId, user));
|
||||
if (personaStatePrompt) messagesPayload.push({role: "system", content: personaStatePrompt});
|
||||
messagesPayload.push(...conversation.map((entry) => ({
|
||||
role: entry.role === "bot" ? "assistant" : "user",
|
||||
content: entry.content
|
||||
})));
|
||||
if (activePersona) messagesPayload.push({role: "system", content: buildRoleplayReplyGuardPrompt()});
|
||||
return {session, activePersona, activeUserPersona, messagesPayload};
|
||||
},
|
||||
buildMessagesPayload: buildConversationContext,
|
||||
async sendChatMessage({user, chatId, message, model}) {
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return {error: "Chat not found", status: 404};
|
||||
|
||||
const payload = this.buildMessagesPayload({user, chatId, message});
|
||||
|
||||
const activePersona = payload.activePersona;
|
||||
const activeUserPersona = payload.activeUserPersona;
|
||||
const messagesPayload = payload.messagesPayload;
|
||||
|
||||
const fullReply = activePersona
|
||||
? await generateValidatedRoleplayReply({selectedModel: model, messagesPayload, userPersona: activeUserPersona})
|
||||
: await modelService.generateReply(model, messagesPayload);
|
||||
|
||||
if (!fullReply) return {error: "Failed to generate a valid character reply", status: 500};
|
||||
|
||||
insertChatMessage(chatId, "user", message);
|
||||
insertChatMessage(chatId, "bot", fullReply, {
|
||||
retryVariants: [fullReply],
|
||||
retryActiveIndex: 0,
|
||||
retryRetriesUsed: 0,
|
||||
retryPromptMessageId: null
|
||||
}, model);
|
||||
repositories.touchChat(chatId, user);
|
||||
await updateContextSummaryWithoutBreakingReply({user, chatId, selectedModel: model});
|
||||
return {reply: fullReply};
|
||||
return generateChatTurn({user, chatId, message, model});
|
||||
},
|
||||
async streamChatMessage({user, chatId, message, model, onChunk}) {
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return {error: "Chat not found", status: 404};
|
||||
|
||||
const payload = this.buildMessagesPayload({user, chatId, message});
|
||||
|
||||
const activePersona = payload.activePersona;
|
||||
const activeUserPersona = payload.activeUserPersona;
|
||||
const messagesPayload = payload.messagesPayload;
|
||||
|
||||
// Persona replies must be validated before any text is exposed to the client.
|
||||
// Normal chats can retain true incremental streaming.
|
||||
const fullReply = activePersona
|
||||
? await generateValidatedRoleplayReply({selectedModel: model, messagesPayload, userPersona: activeUserPersona})
|
||||
: await modelService.streamReply(model, messagesPayload, onChunk);
|
||||
|
||||
if (!fullReply) return {error: "Failed to generate a valid character reply", status: 500};
|
||||
if (activePersona && onChunk) onChunk(fullReply, fullReply);
|
||||
insertChatMessage(chatId, "user", message);
|
||||
insertChatMessage(chatId, "bot", fullReply, {
|
||||
retryVariants: [fullReply],
|
||||
retryActiveIndex: 0,
|
||||
retryRetriesUsed: 0,
|
||||
retryPromptMessageId: null
|
||||
}, model);
|
||||
repositories.touchChat(chatId, user);
|
||||
await updateContextSummaryWithoutBreakingReply({user, chatId, selectedModel: model});
|
||||
return {reply: fullReply};
|
||||
async streamChatMessage({user, chatId, message, model, onChunk, signal = null}) {
|
||||
return generateChatTurn({user, chatId, message, model, onChunk, signal});
|
||||
},
|
||||
async retryMessage({user, chatId, selectedModel, targetMessage, retryStyle = null}) {
|
||||
return withChatGenerationLock(chatId, async () => {
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return {error: "Chat not found", status: 404};
|
||||
|
||||
const freshTarget = repositories.getChatMessage(chatId, targetMessage.id);
|
||||
const existingMessage = formatChatMessage(freshTarget);
|
||||
if (!existingMessage) return {error: "Message not found", status: 404};
|
||||
if (existingMessage.role !== "bot") return {error: "Only assistant messages can be regenerated", status: 400};
|
||||
const siblings = repositories.listSiblingChatMessages(chatId, "bot", freshTarget.parent_message_id);
|
||||
if (siblings.length - 1 >= maxRetries) {
|
||||
return {error: `Maximum of ${maxRetries} retries reached`, status: 400};
|
||||
}
|
||||
const {model, generation} = getGenerationSettings(session, selectedModel);
|
||||
return withActiveGeneration(chatId, null, async (activeSignal) => {
|
||||
const retryResult = await buildRetryPayload({
|
||||
chatId, user, session, selectedModel: model, targetMessage: freshTarget, retryStyle,
|
||||
signal: activeSignal, generation
|
||||
});
|
||||
if (retryResult.error) return {error: retryResult.error, status: 400};
|
||||
const retryVariants = [...siblings.map((sibling) => sibling.content), retryResult.fullReply];
|
||||
const retryState = {
|
||||
retryVariants,
|
||||
retryActiveIndex: retryVariants.length - 1,
|
||||
retryRetriesUsed: siblings.length,
|
||||
retryPromptMessageId: retryResult.promptMessageId
|
||||
};
|
||||
const inserted = repositories.insertBranchChatMessage(
|
||||
chatId, "bot", retryResult.fullReply, retryState, model, "complete", null, freshTarget.parent_message_id
|
||||
);
|
||||
repositories.updateChatContextSummary(chatId, user, null, 0);
|
||||
repositories.touchChat(chatId, user);
|
||||
const message = formatChatMessage(repositories.getChatMessage(chatId, Number(inserted.lastInsertRowid)));
|
||||
return {message, promptMessageId: retryResult.promptMessageId, retryStyle, branchedFromMessageId: freshTarget.id};
|
||||
});
|
||||
});
|
||||
},
|
||||
async editAndResendMessage({user, chatId, targetMessage, content, model, onChunk = null, signal = null}) {
|
||||
if (!targetMessage || targetMessage.role !== "user") return {error: "Only user messages can be edited and resent", status: 400};
|
||||
return generateChatTurn({
|
||||
user,
|
||||
chatId,
|
||||
message: content,
|
||||
model,
|
||||
onChunk,
|
||||
signal,
|
||||
parentMessageId: targetMessage.parent_message_id ?? null
|
||||
});
|
||||
},
|
||||
activateBranch({user, chatId, messageId, includeDescendants = false}) {
|
||||
const session = repositories.getChat(chatId, user);
|
||||
if (!session) return {error: "Chat not found", status: 404};
|
||||
|
||||
const existingMessage = formatChatMessage(targetMessage);
|
||||
if (existingMessage.retryRetriesUsed >= 5) {
|
||||
return {error: "Maximum of 5 retries reached", status: 400};
|
||||
}
|
||||
|
||||
const retryResult = await buildRetryPayload({chatId, user, session, selectedModel, targetMessage, retryStyle});
|
||||
if (retryResult.error) return {error: retryResult.error, status: 400};
|
||||
|
||||
const retryVariants = [...existingMessage.retryVariants, retryResult.fullReply];
|
||||
persistChatMessageRetryState({
|
||||
chatId,
|
||||
messageId: targetMessage.id,
|
||||
content: retryResult.fullReply,
|
||||
retryVariants,
|
||||
retryActiveIndex: retryVariants.length - 1,
|
||||
retryRetriesUsed: existingMessage.retryRetriesUsed + 1,
|
||||
retryPromptMessageId: retryResult.promptMessageId
|
||||
});
|
||||
repositories.touchChat(chatId, user);
|
||||
return {
|
||||
message: formatChatMessage(repositories.getChatMessage(chatId, targetMessage.id)),
|
||||
promptMessageId: retryResult.promptMessageId,
|
||||
retryStyle
|
||||
};
|
||||
const message = repositories.getChatMessage(chatId, messageId);
|
||||
if (!message) return {error: "Message not found", status: 404};
|
||||
const leaf = includeDescendants ? repositories.getLatestDescendantMessage(chatId, messageId) : message;
|
||||
repositories.updateChatActiveLeaf(chatId, user, leaf?.id || messageId);
|
||||
repositories.updateChatContextSummary(chatId, user, null, 0);
|
||||
return {messages: listActiveBranchMessages(chatId)};
|
||||
},
|
||||
listActiveBranchMessages,
|
||||
stopGeneration({user, chatId}) {
|
||||
if (!repositories.getChat(chatId, user)) return {error: "Chat not found", status: 404};
|
||||
const controller = activeGenerations.get(chatId);
|
||||
if (!controller) return {stopped: false};
|
||||
controller.abort();
|
||||
return {stopped: true};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user