mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-16 13:00:55 +00:00
* 🎒 feat: Carry Project Context Across Conversations
* fix: fail a project attach whose upload hold cannot be released and keep file deletes independent of project cleanup
- Attaching a project file now fails, with nothing attached, when the file's
temporary upload hold cannot be released, instead of attaching a file that
can still expire.
- A failed project cleanup after a file delete is logged rather than failing a
delete that already happened, and a user-wide delete clears that user's
project references without reading every file first.
- Both resize handles share the orientation-aware grip, so a primary handle in
a vertical group renders a rotated grip like the alternate one.
* fix: treat an empty tenant id as no tenant in the project file picker
* fix: attach nothing when a project file is deleted while the attach is in flight
* fix: localize project file association failures instead of showing server text
* test: expect a localized reason for a rejected project file association
* fix: scope project file listing to the caller's tenant and name the file limit when attaching an existing file
- Listing a project's attached files now returns not found when the project
belongs to another tenant, matching the available-file listing and the
chat context resolver.
- Choosing an existing file for a full project now names the project file
limit instead of the generic attach error, like the upload path.
* fix: treat an empty tenant id as no tenant in every project tenant check
A caller whose tenant id is an empty string was refused its own tenantless
project when listing attached or available files, because the handlers
compared '' with null. The project handlers and the chat context resolver now
share one comparison that treats an empty tenant id as no tenant, the rule the
project file queries already follow.
* test: wait for the workspace layout swap and the mobile drawer before acting in the long-metadata spec
The desktop title was measured while the phone layout could still be the one
rendered, and the sidebar row menu was opened before the mobile drawer
committed its open state, which closes a menu opened ahead of it. The spec
now waits for the workspace's phone-only sidebar toggle to leave and for the
drawer to drop inert, the same drawer signal the agents helpers use.
* fix: keep the agent context fingerprint of a turn outside any project unchanged
Every turn now passes a project context key into the agent context
fingerprint, and a turn outside any project passed the no-project sentinel,
which changed the digest of every existing no-project checkpoint. An agent
event conversation written before this change then cold-started and reloaded
its history on its next event. The fingerprint now hashes the no-project key
as absent, so those checkpoints keep matching.
* test: load the long-metadata spec at phone width before driving the mobile drawer
The spec crossed back from desktop to phone width without a reload, which
leaves the drawer on the desktop toggle path whose delayed focus handoff to
the close button dismissed the row menu roughly 200ms after it opened. The
spec now reloads at phone width, as a phone arrives, and waits for the
drawer's own focus handoff before opening the menu.
768 lines
27 KiB
JavaScript
768 lines
27 KiB
JavaScript
const path = require('path');
|
|
const { v4 } = require('uuid');
|
|
const { countTokens, announceReply, isAnnounceableReply } = require('@librechat/api');
|
|
const { escapeRegExp } = require('@librechat/data-schemas');
|
|
const {
|
|
Constants,
|
|
ContentTypes,
|
|
AnnotationTypes,
|
|
defaultOrderQuery,
|
|
} = require('librechat-data-provider');
|
|
const {
|
|
saveConvo,
|
|
getMessages,
|
|
spendTokens,
|
|
saveMessage,
|
|
stampConvoLastResponse,
|
|
} = require('~/models');
|
|
const { retrieveAndProcessFile } = require('~/server/services/Files/process');
|
|
|
|
/**
|
|
* Initializes a new thread or adds messages to an existing thread.
|
|
*
|
|
* @param {Object} params - The parameters for initializing a thread.
|
|
* @param {OpenAIClient} params.openai - The OpenAI client instance.
|
|
* @param {Object} params.body - The body of the request.
|
|
* @param {ThreadMessage[]} params.body.messages - A list of messages to start the thread with.
|
|
* @param {Object} [params.body.metadata] - Optional metadata for the thread.
|
|
* @param {string} [params.thread_id] - Optional existing thread ID. If provided, a message will be added to this thread.
|
|
* @return {Promise<Thread>} A promise that resolves to the newly created thread object or the updated thread object.
|
|
*/
|
|
async function initThread({ openai, body, thread_id: _thread_id }) {
|
|
let thread = {};
|
|
const messages = [];
|
|
if (_thread_id) {
|
|
const message = await openai.beta.threads.messages.create(_thread_id, body.messages[0]);
|
|
messages.push(message);
|
|
} else {
|
|
thread = await openai.beta.threads.create(body);
|
|
}
|
|
|
|
const thread_id = _thread_id || thread.id;
|
|
return { messages, thread_id, ...thread };
|
|
}
|
|
|
|
/**
|
|
* Saves a user message to the DB in the Assistants endpoint format.
|
|
*
|
|
* @param {Object} req - The request object.
|
|
* @param {Object} params - The parameters of the user message
|
|
* @param {string} params.user - The user's ID.
|
|
* @param {string} params.text - The user's prompt.
|
|
* @param {string} params.messageId - The user message Id.
|
|
* @param {string} params.model - The model used by the assistant.
|
|
* @param {string} params.assistant_id - The current assistant Id.
|
|
* @param {string} params.thread_id - The thread Id.
|
|
* @param {string} params.conversationId - The message's conversationId
|
|
* @param {string} params.endpoint - The conversation endpoint
|
|
* @param {string} [params.parentMessageId] - Optional if initial message.
|
|
* Defaults to Constants.NO_PARENT.
|
|
* @param {string} [params.instructions] - Optional: from preset for `instructions` field.
|
|
* Overrides the instructions of the assistant.
|
|
* @param {string} [params.promptPrefix] - Optional: from preset for `additional_instructions` field.
|
|
* @param {import('librechat-data-provider').TFile[]} [params.files] - Optional. List of Attached File Objects.
|
|
* @param {string[]} [params.file_ids] - Optional. List of File IDs attached to the userMessage.
|
|
* @return {Promise<Run>} A promise that resolves to the created run object.
|
|
*/
|
|
async function saveUserMessage(req, params) {
|
|
const tokenCount = await countTokens(params.text);
|
|
|
|
const userMessage = {
|
|
user: params.user,
|
|
endpoint: params.endpoint,
|
|
messageId: params.messageId,
|
|
conversationId: params.conversationId,
|
|
parentMessageId: params.parentMessageId ?? Constants.NO_PARENT,
|
|
/* For messages, use the assistant_id instead of model */
|
|
model: params.assistant_id,
|
|
thread_id: params.thread_id,
|
|
sender: 'User',
|
|
text: params.text,
|
|
isCreatedByUser: true,
|
|
tokenCount,
|
|
};
|
|
|
|
// Only confirmed new conversations seed membership; saveConvo applies it on insert.
|
|
const chatProjectId =
|
|
req?.resolvedConversation === null ? req.chatProjectContext?.projectId : undefined;
|
|
const convo = {
|
|
endpoint: params.endpoint,
|
|
conversationId: params.conversationId,
|
|
promptPrefix: params.promptPrefix,
|
|
instructions: params.instructions,
|
|
assistant_id: params.assistant_id,
|
|
model: params.model,
|
|
...(typeof chatProjectId === 'string' && chatProjectId ? { chatProjectId } : {}),
|
|
};
|
|
if (params.files?.length) {
|
|
userMessage.files = params.files.map(({ file_id }) => ({ file_id }));
|
|
convo.file_ids = params.file_ids;
|
|
}
|
|
|
|
const ctx = {
|
|
userId: req?.user?.id,
|
|
isTemporary: req?.resolvedConversation?.isTemporary ?? req?.body?.isTemporary,
|
|
expiredAt: req?.resolvedConversation?.expiredAt,
|
|
interfaceConfig: req?.config?.interfaceConfig,
|
|
};
|
|
const message = await saveMessage(ctx, userMessage);
|
|
const savedConvo = await saveConvo(
|
|
{ ...ctx, expiredAt: message?.expiredAt ?? ctx.expiredAt },
|
|
convo,
|
|
{
|
|
context: 'api/server/services/Threads/manage.js #saveUserMessage',
|
|
...(message?._id != null ? { appendMessageIds: [message._id] } : {}),
|
|
},
|
|
);
|
|
if (savedConvo != null) {
|
|
req.resolvedConversation = savedConvo;
|
|
}
|
|
return message;
|
|
}
|
|
|
|
/**
|
|
* Saves an Assistant message to the DB in the Assistants endpoint format.
|
|
*
|
|
* @param {Object} req - The request object.
|
|
* @param {Object} params - The parameters of the Assistant message
|
|
* @param {string} params.user - The user's ID.
|
|
* @param {string} params.messageId - The message Id.
|
|
* @param {string} params.text - The concatenated text of the message.
|
|
* @param {string} params.assistant_id - The assistant Id.
|
|
* @param {string} params.thread_id - The thread Id.
|
|
* @param {string} params.model - The model used by the assistant.
|
|
* @param {ContentPart[]} params.content - The message content parts.
|
|
* @param {string} params.conversationId - The message's conversationId
|
|
* @param {string} params.endpoint - The conversation endpoint
|
|
* @param {string} params.parentMessageId - The latest user message that triggered this response.
|
|
* @param {string} [params.instructions] - Optional: from preset for `instructions` field.
|
|
* @param {string} [params.spec] - Optional: Model spec identifier.
|
|
* @param {string} [params.iconURL]
|
|
* @param {import('librechat-data-provider').TAttachment[]} [params.attachments]
|
|
* Overrides the instructions of the assistant.
|
|
* @param {string} [params.promptPrefix] - Optional: from preset for `additional_instructions` field.
|
|
* @return {Promise<{message: Object|null, conversation: Object|null}>} The persisted assistant
|
|
* message and the conversation snapshot settled by the same write.
|
|
*/
|
|
async function saveAssistantMessage(req, params) {
|
|
// const tokenCount = // TODO: need to count each content part
|
|
|
|
const ctx = {
|
|
userId: req?.user?.id,
|
|
isTemporary: req?.resolvedConversation?.isTemporary ?? req?.body?.isTemporary,
|
|
expiredAt: req?.resolvedConversation?.expiredAt,
|
|
interfaceConfig: req?.config?.interfaceConfig,
|
|
};
|
|
const message = await saveMessage(ctx, {
|
|
user: params.user,
|
|
endpoint: params.endpoint,
|
|
messageId: params.messageId,
|
|
conversationId: params.conversationId,
|
|
parentMessageId: params.parentMessageId,
|
|
thread_id: params.thread_id,
|
|
/* For messages, use the assistant_id instead of model */
|
|
model: params.assistant_id,
|
|
content: params.content,
|
|
attachments: params.attachments,
|
|
sender: 'Assistant',
|
|
isCreatedByUser: false,
|
|
text: params.text,
|
|
unfinished: false,
|
|
// tokenCount,
|
|
iconURL: params.iconURL,
|
|
spec: params.spec,
|
|
});
|
|
|
|
const announceable = isAnnounceableReply({
|
|
messageId: message?.messageId,
|
|
content: params.content,
|
|
text: params.text,
|
|
isTemporary: ctx.isTemporary,
|
|
});
|
|
|
|
const savedConvo = await saveConvo(
|
|
{ ...ctx, expiredAt: message?.expiredAt ?? ctx.expiredAt },
|
|
{
|
|
endpoint: params.endpoint,
|
|
conversationId: params.conversationId,
|
|
promptPrefix: params.promptPrefix,
|
|
instructions: params.instructions,
|
|
assistant_id: params.assistant_id,
|
|
model: params.model,
|
|
iconURL: params.iconURL,
|
|
spec: params.spec,
|
|
},
|
|
{
|
|
context: 'api/server/services/Threads/manage.js #saveAssistantMessage',
|
|
/** Judged by the same predicate every other persistence path asks, so an assistant row
|
|
* that renders nothing cannot raise a dot here that opening the chat can never clear.
|
|
* `saveConvo` assigns the timestamp past its own awaited reads, so a catch-up recorded
|
|
* while one of them is in flight cannot outrank this reply. */
|
|
stampReply: announceable,
|
|
...(announceable ? { replyMessageId: message.messageId } : {}),
|
|
...(message?._id != null ? { appendMessageIds: [message._id] } : {}),
|
|
},
|
|
);
|
|
|
|
if (savedConvo != null) {
|
|
req.resolvedConversation = savedConvo;
|
|
}
|
|
|
|
return { message, conversation: savedConvo };
|
|
}
|
|
|
|
/**
|
|
* Records LibreChat messageId to all response messages' metadata
|
|
*
|
|
* @param {Object} params - The parameters for initializing a thread.
|
|
* @param {OpenAIClient} params.openai - The OpenAI client instance.
|
|
* @param {string} params.thread_id - Response thread ID.
|
|
* @param {string} params.messageId - The response `messageId` generated by LibreChat.
|
|
* @param {StepMessage[] | Message[]} params.messages - A list of messages to start the thread with.
|
|
* @return {Promise<ThreadMessage[]>} A promise that resolves to the updated messages
|
|
*/
|
|
async function addThreadMetadata({ openai, thread_id, messageId, messages }) {
|
|
const promises = [];
|
|
for (const message of messages) {
|
|
promises.push(
|
|
openai.beta.threads.messages.update(message.id, {
|
|
thread_id,
|
|
metadata: {
|
|
messageId,
|
|
},
|
|
}),
|
|
);
|
|
}
|
|
|
|
return await Promise.all(promises);
|
|
}
|
|
|
|
/**
|
|
* Synchronizes LibreChat messages to Thread Messages.
|
|
* Updates the LibreChat DB with any missing Thread Messages and
|
|
* updates the missing Thread Messages' metadata with their corresponding db messageId's.
|
|
*
|
|
* Also updates the existing conversation's file_ids with any new file_ids.
|
|
*
|
|
* @param {Object} params - The parameters for synchronizing messages.
|
|
* @param {OpenAIClient} params.openai - The OpenAI client instance.
|
|
* @param {string} params.endpoint - The current endpoint.
|
|
* @param {string} params.thread_id - The current thread ID.
|
|
* @param {TMessage[]} params.dbMessages - The LibreChat DB messages.
|
|
* @param {ThreadMessage[]} params.apiMessages - The thread messages from the API.
|
|
* @param {string} [params.assistant_id] - The current assistant ID.
|
|
* @param {string} params.conversationId - The current conversation ID.
|
|
* @return {Promise<TMessage[]>} A promise that resolves to the updated messages
|
|
*/
|
|
async function syncMessages({
|
|
openai,
|
|
endpoint,
|
|
thread_id,
|
|
dbMessages,
|
|
apiMessages,
|
|
assistant_id,
|
|
conversationId,
|
|
}) {
|
|
let result = [];
|
|
let dbMessageMap = new Map(dbMessages.map((msg) => [msg.messageId, msg]));
|
|
|
|
const modifyPromises = [];
|
|
const recordPromises = [];
|
|
const ctx = {
|
|
userId: openai.req?.user?.id,
|
|
isTemporary: openai.req?.resolvedConversation?.isTemporary ?? openai.req?.body?.isTemporary,
|
|
expiredAt: openai.req?.resolvedConversation?.expiredAt,
|
|
interfaceConfig: openai.req?.config?.interfaceConfig,
|
|
};
|
|
/** The assistant writes this synchronization performed. Their results decide whether a reply
|
|
* is actually in the history: a write that resolved empty must not raise an indicator. */
|
|
const assistantRecordPromises = [];
|
|
|
|
/**
|
|
*
|
|
* Modify API message and save newMessage to DB
|
|
*
|
|
* @param {Object} params - The parameters object
|
|
* @param {TMessage} params.dbMessage
|
|
* @param {dbMessage} params.apiMessage
|
|
*/
|
|
const processNewMessage = async ({ dbMessage, apiMessage }) => {
|
|
const recorded = saveMessage(ctx, { ...dbMessage, user: openai.req.user.id });
|
|
recordPromises.push(recorded);
|
|
if (dbMessage.role === 'assistant') {
|
|
assistantRecordPromises.push(recorded);
|
|
}
|
|
|
|
if (!apiMessage.id.includes('msg_')) {
|
|
return;
|
|
}
|
|
|
|
if (dbMessage.aggregateMessages?.length > 1) {
|
|
modifyPromises.push(
|
|
addThreadMetadata({
|
|
openai,
|
|
thread_id,
|
|
messageId: dbMessage.messageId,
|
|
messages: dbMessage.aggregateMessages,
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
|
|
modifyPromises.push(
|
|
openai.beta.threads.messages.update(apiMessage.id, {
|
|
thread_id,
|
|
metadata: {
|
|
messageId: dbMessage.messageId,
|
|
},
|
|
}),
|
|
);
|
|
};
|
|
|
|
let lastMessage = null;
|
|
|
|
for (let i = 0; i < apiMessages.length; i++) {
|
|
const apiMessage = apiMessages[i];
|
|
|
|
// Check if the message exists in the database based on metadata
|
|
const dbMessageId = apiMessage.metadata && apiMessage.metadata.messageId;
|
|
let dbMessage = dbMessageMap.get(dbMessageId);
|
|
|
|
if (dbMessage) {
|
|
// If message exists in DB, use its messageId and update parentMessageId
|
|
dbMessage.parentMessageId = lastMessage ? lastMessage.messageId : Constants.NO_PARENT;
|
|
lastMessage = dbMessage;
|
|
result.push(dbMessage);
|
|
continue;
|
|
}
|
|
|
|
if (apiMessage.role === 'assistant' && lastMessage && lastMessage.role === 'assistant') {
|
|
// Aggregate assistant messages
|
|
lastMessage.content = [...lastMessage.content, ...apiMessage.content];
|
|
lastMessage.files = [...(lastMessage.files ?? []), ...(apiMessage.files ?? [])];
|
|
lastMessage.aggregateMessages.push({ id: apiMessage.id });
|
|
} else {
|
|
// Handle new or missing message
|
|
const newMessage = {
|
|
thread_id,
|
|
conversationId,
|
|
messageId: v4(),
|
|
endpoint,
|
|
parentMessageId: lastMessage ? lastMessage.messageId : Constants.NO_PARENT,
|
|
role: apiMessage.role,
|
|
isCreatedByUser: apiMessage.role === 'user',
|
|
// TODO: process generated files in content parts
|
|
content: apiMessage.content,
|
|
aggregateMessages: [{ id: apiMessage.id }],
|
|
model: apiMessage.role === 'user' ? null : apiMessage.assistant_id,
|
|
user: openai.req.user.id,
|
|
unfinished: false,
|
|
};
|
|
|
|
if (apiMessage.file_ids?.length) {
|
|
// TODO: retrieve file objects from API
|
|
newMessage.files = apiMessage.file_ids.map((file_id) => ({ file_id }));
|
|
}
|
|
|
|
/* Assign assistant_id if defined */
|
|
if (assistant_id && apiMessage.role === 'assistant' && !newMessage.model) {
|
|
apiMessage.model = assistant_id;
|
|
newMessage.model = assistant_id;
|
|
}
|
|
|
|
result.push(newMessage);
|
|
lastMessage = newMessage;
|
|
|
|
if (apiMessage.role === 'user') {
|
|
processNewMessage({ dbMessage: newMessage, apiMessage });
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const nextMessage = apiMessages[i + 1];
|
|
const processAssistant = !nextMessage || nextMessage.role === 'user';
|
|
|
|
if (apiMessage.role === 'assistant' && processAssistant) {
|
|
processNewMessage({ dbMessage: lastMessage, apiMessage });
|
|
}
|
|
}
|
|
|
|
const attached_file_ids = apiMessages.reduce((acc, msg) => {
|
|
if (msg.role === 'user' && msg.file_ids?.length) {
|
|
return [...acc, ...msg.file_ids];
|
|
}
|
|
|
|
return acc;
|
|
}, []);
|
|
|
|
await Promise.all(modifyPromises);
|
|
const recordedAssistantReplies = await Promise.all(assistantRecordPromises);
|
|
await Promise.all(recordPromises);
|
|
|
|
const savedConvo = await saveConvo(
|
|
ctx,
|
|
{
|
|
conversationId,
|
|
file_ids: attached_file_ids,
|
|
},
|
|
{ context: 'api/server/services/Threads/manage.js #syncMessages' },
|
|
);
|
|
if (savedConvo != null) {
|
|
openai.req.resolvedConversation = savedConvo;
|
|
}
|
|
|
|
/* Every caller that reaches here recovers assistant output the normal save path never wrote:
|
|
a cancelled run, or one that errored after the model had already produced content. The
|
|
`saveConvo` above carries no reply stamp, so without this the recovered reply would never
|
|
raise its unseen indicator. Only a write that actually persisted counts, and it is
|
|
best-effort, since those messages are already durable.
|
|
A run cancelled before any output still persists the synthetic row `checkMessageGaps`
|
|
built, and the error handlers add their visible content to the returned object rather
|
|
than to that row: stamping it would raise a dot for a message that renders nothing, and
|
|
acknowledgement requires the stamped reply to be on screen. */
|
|
const persistedAssistantReply = recordedAssistantReplies.findLast((message) => message != null);
|
|
await announceReply(
|
|
{ stampConvoLastResponse },
|
|
{
|
|
userId: openai.req.user.id,
|
|
conversationId,
|
|
reply: { ...persistedAssistantReply, isTemporary: ctx.isTemporary },
|
|
context: 'syncMessages',
|
|
},
|
|
);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Maps messages to their corresponding steps. Steps with message creation will be paired with their messages,
|
|
* while steps without message creation will be returned as is.
|
|
*
|
|
* @param {RunStep[]} steps - An array of steps from the run.
|
|
* @param {Message[]} messages - An array of message objects.
|
|
* @returns {(StepMessage | RunStep)[]} An array where each element is either a step with its corresponding message (StepMessage) or a step without a message (RunStep).
|
|
*/
|
|
function mapMessagesToSteps(steps, messages) {
|
|
// Create a map of messages indexed by their IDs for efficient lookup
|
|
const messageMap = messages.reduce((acc, msg) => {
|
|
acc[msg.id] = msg;
|
|
return acc;
|
|
}, {});
|
|
|
|
// Map each step to its corresponding message, or return the step as is if no message ID is present
|
|
return steps
|
|
.sort((a, b) => a.created_at - b.created_at)
|
|
.map((step) => {
|
|
const messageId = step.step_details?.message_creation?.message_id;
|
|
|
|
if (messageId && messageMap[messageId]) {
|
|
return { step, message: messageMap[messageId] };
|
|
}
|
|
return step;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Checks for any missing messages; if missing,
|
|
* synchronizes LibreChat messages to Thread Messages
|
|
*
|
|
* @param {Object} params - The parameters for initializing a thread.
|
|
* @param {OpenAIClient} params.openai - The OpenAI client instance.
|
|
* @param {string} params.endpoint - The current endpoint.
|
|
* @param {string} [params.latestMessageId] - Optional: The latest message ID from LibreChat.
|
|
* @param {string} params.thread_id - Response thread ID.
|
|
* @param {string} params.run_id - Response Run ID.
|
|
* @param {string} params.conversationId - LibreChat conversation ID.
|
|
* @return {Promise<TMessage[]>} A promise that resolves to the updated messages
|
|
*/
|
|
async function checkMessageGaps({
|
|
openai,
|
|
endpoint,
|
|
latestMessageId,
|
|
thread_id,
|
|
run_id,
|
|
conversationId,
|
|
}) {
|
|
const promises = [];
|
|
promises.push(openai.beta.threads.messages.list(thread_id, defaultOrderQuery));
|
|
promises.push(openai.beta.threads.runs.steps.list(run_id, { thread_id }));
|
|
/** @type {[{ data: ThreadMessage[] }, { data: RunStep[] }]} */
|
|
const [response, stepsResponse] = await Promise.all(promises);
|
|
|
|
const steps = mapMessagesToSteps(stepsResponse.data, response.data);
|
|
/** @type {ThreadMessage} */
|
|
const currentMessage = {
|
|
id: v4(),
|
|
content: [],
|
|
assistant_id: null,
|
|
created_at: Math.floor(new Date().getTime() / 1000),
|
|
object: 'thread.message',
|
|
role: 'assistant',
|
|
run_id,
|
|
thread_id,
|
|
endpoint,
|
|
metadata: {
|
|
messageId: latestMessageId,
|
|
},
|
|
};
|
|
|
|
for (const step of steps) {
|
|
if (!currentMessage.assistant_id && step.assistant_id) {
|
|
currentMessage.assistant_id = step.assistant_id;
|
|
}
|
|
if (step.message) {
|
|
currentMessage.id = step.message.id;
|
|
currentMessage.created_at = step.message.created_at;
|
|
currentMessage.content = currentMessage.content.concat(step.message.content);
|
|
} else if (step.step_details?.type === 'tool_calls' && step.step_details?.tool_calls?.length) {
|
|
currentMessage.content = currentMessage.content.concat(
|
|
step.step_details?.tool_calls.map((toolCall) => ({
|
|
[ContentTypes.TOOL_CALL]: {
|
|
...toolCall,
|
|
progress: 2,
|
|
},
|
|
type: ContentTypes.TOOL_CALL,
|
|
})),
|
|
);
|
|
}
|
|
}
|
|
|
|
let addedCurrentMessage = false;
|
|
const apiMessages = response.data
|
|
.map((msg) => {
|
|
if (msg.id === currentMessage.id) {
|
|
addedCurrentMessage = true;
|
|
return currentMessage;
|
|
}
|
|
return msg;
|
|
})
|
|
.sort((a, b) => new Date(a.created_at) - new Date(b.created_at));
|
|
|
|
if (!addedCurrentMessage) {
|
|
apiMessages.push(currentMessage);
|
|
}
|
|
|
|
const dbMessages = await getMessages({ conversationId, user: openai.req.user.id });
|
|
const assistant_id = dbMessages?.[0]?.model;
|
|
|
|
const syncedMessages = await syncMessages({
|
|
openai,
|
|
endpoint,
|
|
thread_id,
|
|
dbMessages,
|
|
apiMessages,
|
|
assistant_id,
|
|
conversationId,
|
|
});
|
|
|
|
return Object.values(
|
|
[...dbMessages, ...syncedMessages].reduce(
|
|
(acc, message) => ({ ...acc, [message.messageId]: message }),
|
|
{},
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Records token usage for a given completion request.
|
|
* @param {Object} params - The parameters for initializing a thread.
|
|
* @param {number} params.prompt_tokens - The number of prompt tokens used.
|
|
* @param {number} params.completion_tokens - The number of completion tokens used.
|
|
* @param {string} params.model - The model used by the assistant run.
|
|
* @param {string} params.user - The user's ID.
|
|
* @param {string} params.conversationId - LibreChat conversation ID.
|
|
* @param {string} [params.context='message'] - The context of the usage. Defaults to 'message'.
|
|
* @param {AppConfig['transactions']} [params.transactions] - Resolved transactions config.
|
|
* @return {Promise<void>}
|
|
*/
|
|
const recordUsage = async ({
|
|
prompt_tokens,
|
|
completion_tokens,
|
|
model,
|
|
user,
|
|
conversationId,
|
|
context = 'message',
|
|
transactions,
|
|
}) => {
|
|
await spendTokens(
|
|
{
|
|
user,
|
|
model,
|
|
context,
|
|
conversationId,
|
|
transactions,
|
|
},
|
|
{ promptTokens: prompt_tokens, completionTokens: completion_tokens },
|
|
);
|
|
};
|
|
|
|
const uniqueCitationStart = '^====||===';
|
|
const uniqueCitationEnd = '==|||||^';
|
|
|
|
/**
|
|
* Sorts, processes, and flattens messages to a single string.
|
|
*
|
|
* @param {object} params - The parameters for processing messages.
|
|
* @param {OpenAIClient} params.openai - The OpenAI client instance.
|
|
* @param {RunClient} params.client - The LibreChat client that manages the run: either refers to `OpenAI` or `StreamRunManager`.
|
|
* @param {ThreadMessage[]} params.messages - An array of messages.
|
|
* @returns {Promise<{messages: ThreadMessage[], text: string, edited: boolean}>} The sorted messages, the flattened text, and whether it was edited.
|
|
*/
|
|
async function processMessages({ openai, client, messages = [] }) {
|
|
const sorted = messages.sort((a, b) => a.created_at - b.created_at);
|
|
|
|
let text = '';
|
|
let edited = false;
|
|
const sources = new Map();
|
|
const fileRetrievalPromises = [];
|
|
|
|
for (const message of sorted) {
|
|
message.files = [];
|
|
for (const content of message.content) {
|
|
const type = content.type;
|
|
const contentType = content[type];
|
|
const currentFileId = contentType?.file_id;
|
|
|
|
if (type === ContentTypes.IMAGE_FILE && !client.processedFileIds.has(currentFileId)) {
|
|
fileRetrievalPromises.push(
|
|
retrieveAndProcessFile({
|
|
openai,
|
|
client,
|
|
file_id: currentFileId,
|
|
basename: `${currentFileId}.png`,
|
|
})
|
|
.then((file) => {
|
|
client.processedFileIds.add(currentFileId);
|
|
message.files.push(file);
|
|
})
|
|
.catch((error) => {
|
|
console.error(`Failed to retrieve file: ${error.message}`);
|
|
}),
|
|
);
|
|
continue;
|
|
}
|
|
|
|
let currentText = contentType?.value ?? '';
|
|
|
|
/** @type {{ annotations: Annotation[] }} */
|
|
const { annotations } = contentType ?? {};
|
|
|
|
if (!annotations?.length) {
|
|
text += currentText;
|
|
continue;
|
|
}
|
|
|
|
const replacements = [];
|
|
const annotationPromises = annotations.map(async (annotation) => {
|
|
const type = annotation.type;
|
|
const annotationType = annotation[type];
|
|
const file_id = annotationType?.file_id;
|
|
const alreadyProcessed = client.processedFileIds.has(file_id);
|
|
|
|
let file;
|
|
let replacementText = '';
|
|
|
|
try {
|
|
if (alreadyProcessed) {
|
|
file = await retrieveAndProcessFile({ openai, client, file_id, unknownType: true });
|
|
} else if (type === AnnotationTypes.FILE_PATH) {
|
|
const basename = path.basename(annotation.text);
|
|
file = await retrieveAndProcessFile({
|
|
openai,
|
|
client,
|
|
file_id,
|
|
basename,
|
|
});
|
|
replacementText = file.filepath;
|
|
} else if (type === AnnotationTypes.FILE_CITATION && file_id) {
|
|
file = await retrieveAndProcessFile({
|
|
openai,
|
|
client,
|
|
file_id,
|
|
unknownType: true,
|
|
});
|
|
if (file && file.filename) {
|
|
if (!sources.has(file.filename)) {
|
|
sources.set(file.filename, sources.size + 1);
|
|
}
|
|
replacementText = `${uniqueCitationStart}${sources.get(
|
|
file.filename,
|
|
)}${uniqueCitationEnd}`;
|
|
}
|
|
}
|
|
|
|
if (file && replacementText) {
|
|
replacements.push({
|
|
start: annotation.start_index,
|
|
end: annotation.end_index,
|
|
text: replacementText,
|
|
});
|
|
edited = true;
|
|
if (!alreadyProcessed) {
|
|
client.processedFileIds.add(file_id);
|
|
message.files.push(file);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
console.error(`Failed to process annotation: ${error.message}`);
|
|
}
|
|
});
|
|
|
|
await Promise.all(annotationPromises);
|
|
|
|
// Apply replacements in reverse order
|
|
replacements.sort((a, b) => b.start - a.start);
|
|
for (const { start, end, text: replacementText } of replacements) {
|
|
currentText = currentText.slice(0, start) + replacementText + currentText.slice(end);
|
|
}
|
|
|
|
text += currentText;
|
|
}
|
|
}
|
|
|
|
await Promise.all(fileRetrievalPromises);
|
|
|
|
// Handle adjacent identical citations with the unique format
|
|
const adjacentCitationRegex = new RegExp(
|
|
`${escapeRegExp(uniqueCitationStart)}(\\d+)${escapeRegExp(
|
|
uniqueCitationEnd,
|
|
)}(\\s*)${escapeRegExp(uniqueCitationStart)}(\\d+)${escapeRegExp(uniqueCitationEnd)}`,
|
|
'g',
|
|
);
|
|
text = text.replace(adjacentCitationRegex, (match, num1, space, num2) => {
|
|
return num1 === num2
|
|
? `${uniqueCitationStart}${num1}${uniqueCitationEnd}`
|
|
: `${uniqueCitationStart}${num1}${uniqueCitationEnd}${space}${uniqueCitationStart}${num2}${uniqueCitationEnd}`;
|
|
});
|
|
|
|
// Remove any remaining adjacent identical citations
|
|
const remainingAdjacentRegex = new RegExp(
|
|
`(${escapeRegExp(uniqueCitationStart)}(\\d+)${escapeRegExp(uniqueCitationEnd)})\\s*\\1+`,
|
|
'g',
|
|
);
|
|
text = text.replace(remainingAdjacentRegex, '$1');
|
|
|
|
// Replace the unique citation format with the final format
|
|
text = text.replace(new RegExp(escapeRegExp(uniqueCitationStart), 'g'), '^');
|
|
text = text.replace(new RegExp(escapeRegExp(uniqueCitationEnd), 'g'), '^');
|
|
|
|
if (sources.size) {
|
|
text += '\n\n';
|
|
Array.from(sources.entries()).forEach(([source, index], arrayIndex) => {
|
|
text += `^${index}.^ ${source}${arrayIndex === sources.size - 1 ? '' : '\n'}`;
|
|
});
|
|
}
|
|
|
|
return { messages: sorted, text, edited };
|
|
}
|
|
|
|
module.exports = {
|
|
initThread,
|
|
recordUsage,
|
|
processMessages,
|
|
saveUserMessage,
|
|
checkMessageGaps,
|
|
addThreadMetadata,
|
|
mapMessagesToSteps,
|
|
saveAssistantMessage,
|
|
};
|