@librechat/data-schemas 0.0.35 → 0.0.37

package/dist/index.cjs

@@ -1462,12 +1462,57 @@ const agentSchema = new mongoose.Schema({
         default: [],
         index: true,
     },
+    /** Per-tool configuration (defer_loading, allowed_callers) */
+    tool_options: {
+        type: mongoose.Schema.Types.Mixed,
+        default: undefined,
+    },
 }, {
     timestamps: true,
 });
 agentSchema.index({ updatedAt: -1, _id: 1 });
 agentSchema.index({ 'edges.to': 1 });
 
+const agentApiKeySchema = new mongoose.Schema({
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+        index: true,
+    },
+    name: {
+        type: String,
+        required: true,
+        trim: true,
+        maxlength: 100,
+    },
+    keyHash: {
+        type: String,
+        required: true,
+        select: false,
+        index: true,
+    },
+    keyPrefix: {
+        type: String,
+        required: true,
+        index: true,
+    },
+    lastUsedAt: {
+        type: Date,
+    },
+    expiresAt: {
+        type: Date,
+    },
+}, { timestamps: true });
+agentApiKeySchema.index({ userId: 1, name: 1 });
+/**
+ * TTL index for automatic cleanup of expired keys.
+ * MongoDB deletes documents when expiresAt passes (expireAfterSeconds: 0 means immediate).
+ * Note: Expired keys are permanently removed, not soft-deleted.
+ * If audit trails are needed, remove this index and check expiration programmatically.
+ */
+agentApiKeySchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
 const agentCategorySchema = new mongoose.Schema({
     value: {
         type: String,
@@ -1730,6 +1775,12 @@ const conversationPreset = {
     thinkingBudget: {
         type: Number,
     },
+    thinkingLevel: {
+        type: String,
+    },
+    effort: {
+        type: String,
+    },
     system: {
         type: String,
     },
@@ -1856,6 +1907,10 @@ const file = new mongoose.Schema({
         ref: 'Conversation',
         index: true,
     },
+    messageId: {
+        type: String,
+        index: true,
+    },
     file_id: {
         type: String,
         index: true,
@@ -1919,6 +1974,7 @@ const file = new mongoose.Schema({
     timestamps: true,
 });
 file.index({ createdAt: 1, updatedAt: 1 });
+file.index({ filename: 1, conversationId: 1, context: 1 }, { unique: true, partialFilterExpression: { context: librechatDataProvider.FileContext.execute_code } });
 
 const keySchema = new mongoose.Schema({
     userId: {
@@ -2296,6 +2352,12 @@ const rolePermissionsSchema = new mongoose.Schema({
         [librechatDataProvider.Permissions.SHARE]: { type: Boolean },
         [librechatDataProvider.Permissions.SHARE_PUBLIC]: { type: Boolean },
     },
+    [librechatDataProvider.PermissionTypes.REMOTE_AGENTS]: {
+        [librechatDataProvider.Permissions.USE]: { type: Boolean },
+        [librechatDataProvider.Permissions.CREATE]: { type: Boolean },
+        [librechatDataProvider.Permissions.SHARE]: { type: Boolean },
+        [librechatDataProvider.Permissions.SHARE_PUBLIC]: { type: Boolean },
+    },
 }, { _id: false });
 const roleSchema = new mongoose.Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -2453,6 +2515,7 @@ const transactionSchema = new mongoose.Schema({
     inputTokens: { type: Number },
     writeTokens: { type: Number },
     readTokens: { type: Number },
+    messageId: { type: String },
 }, {
     timestamps: true,
 });
@@ -2680,6 +2743,7 @@ groupSchema.index({ idOnTheSource: 1, source: 1 }, {
 });
 groupSchema.index({ memberIds: 1 });
 
+const CANCEL_RATE = 1.15;
 /**
  * Checks if the connected MongoDB deployment supports transactions
  * This requires a MongoDB replica set configuration
@@ -2870,8 +2934,8 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, syncOptions, }) =>
         }
         /**
          * Synchronizes data between the MongoDB collection and the MeiliSearch index by
-         * incrementally indexing only documents where `expiredAt` is `null` and `_meiliIndex` is `false`
-         * (i.e., non-expired documents that have not yet been indexed).
+         * incrementally indexing only documents where `expiredAt` is `null` and `_meiliIndex` is not `true`
+         * (i.e., non-expired documents that have not yet been indexed, including those with missing or null `_meiliIndex`).
          * */
         static async syncWithMeili() {
             const startTime = Date.now();
@@ -2896,7 +2960,7 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, syncOptions, }) =>
             while (hasMore) {
                 const query = {
                     expiredAt: null,
-                    _meiliIndex: false,
+                    _meiliIndex: { $ne: true },
                 };
                 try {
                     const documents = await this.find(query)
@@ -3359,6 +3423,10 @@ function createAgentModel(mongoose) {
     return mongoose.models.Agent || mongoose.model('Agent', agentSchema);
 }
 
+function createAgentApiKeyModel(mongoose) {
+    return (mongoose.models.AgentApiKey || mongoose.model('AgentApiKey', agentApiKeySchema));
+}
+
 /**
  * Creates or returns the AgentCategory model using the provided mongoose instance and schema
  */
@@ -3522,7 +3590,7 @@ const accessRoleSchema = new mongoose.Schema({
     description: String,
     resourceType: {
         type: String,
-        enum: ['agent', 'project', 'file', 'promptGroup', 'mcpServer'],
+        enum: ['agent', 'project', 'file', 'promptGroup', 'mcpServer', 'remoteAgent'],
         required: true,
         default: 'agent',
     },
@@ -3622,6 +3690,7 @@ function createModels(mongoose) {
         Conversation: createConversationModel(mongoose),
         Message: createMessageModel(mongoose),
         Agent: createAgentModel(mongoose),
+        AgentApiKey: createAgentApiKeyModel(mongoose),
         AgentCategory: createAgentCategoryModel(mongoose),
         MCPServer: createMCPServerModel(mongoose),
         Role: createRoleModel(mongoose),
@@ -4435,30 +4504,33 @@ function createFileMethods(mongoose) {
         return await query.sort(sortOptions).lean();
     }
     /**
-     * Retrieves tool files (files that are embedded or have a fileIdentifier) from an array of file IDs
+     * Retrieves tool files (files that are embedded or have a fileIdentifier) from an array of file IDs.
+     * Note: execute_code files are handled separately by getCodeGeneratedFiles.
      * @param fileIds - Array of file_id strings to search for
      * @param toolResourceSet - Optional filter for tool resources
      * @returns Files that match the criteria
      */
     async function getToolFilesByIds(fileIds, toolResourceSet) {
-        var _a, _b, _c;
         if (!fileIds || !fileIds.length || !(toolResourceSet === null || toolResourceSet === void 0 ? void 0 : toolResourceSet.size)) {
             return [];
         }
         try {
-            const filter = {
-                file_id: { $in: fileIds },
-                $or: [],
-            };
+            const orConditions = [];
             if (toolResourceSet.has(librechatDataProvider.EToolResources.context)) {
-                (_a = filter.$or) === null || _a === void 0 ? void 0 : _a.push({ text: { $exists: true, $ne: null }, context: librechatDataProvider.FileContext.agents });
+                orConditions.push({ text: { $exists: true, $ne: null }, context: librechatDataProvider.FileContext.agents });
             }
             if (toolResourceSet.has(librechatDataProvider.EToolResources.file_search)) {
-                (_b = filter.$or) === null || _b === void 0 ? void 0 : _b.push({ embedded: true });
+                orConditions.push({ embedded: true });
             }
-            if (toolResourceSet.has(librechatDataProvider.EToolResources.execute_code)) {
-                (_c = filter.$or) === null || _c === void 0 ? void 0 : _c.push({ 'metadata.fileIdentifier': { $exists: true } });
+            // If no conditions to match, return empty
+            if (orConditions.length === 0) {
+                return [];
             }
+            const filter = {
+                file_id: { $in: fileIds },
+                context: { $ne: librechatDataProvider.FileContext.execute_code },
+                $or: orConditions,
+            };
             const selectFields = { text: 0 };
             const sortOptions = { updatedAt: -1 };
             const results = await getFiles(filter, sortOptions, selectFields);
@@ -4469,6 +4541,91 @@ function createFileMethods(mongoose) {
             throw new Error('Error retrieving tool files');
         }
     }
+    /**
+     * Retrieves files generated by code execution for a given conversation.
+     * These files are stored locally with fileIdentifier metadata for code env re-upload.
+     *
+     * @param conversationId - The conversation ID to search for
+     * @param messageIds - Array of messageIds to filter by (for linear thread filtering).
+     *   While technically optional, this function returns empty if not provided.
+     *   This is intentional: code-generated files must be filtered by thread to avoid
+     *   including files from other branches of a conversation.
+     * @returns Files generated by code execution in the conversation, filtered by messageIds
+     */
+    async function getCodeGeneratedFiles(conversationId, messageIds) {
+        if (!conversationId) {
+            return [];
+        }
+        /**
+         * Return early if messageIds not provided - this is intentional behavior.
+         * Code-generated files must be filtered by thread messageIds to ensure we only
+         * return files relevant to the current conversation branch, not orphaned files
+         * from other branches or deleted messages.
+         */
+        if (!messageIds || messageIds.length === 0) {
+            return [];
+        }
+        try {
+            const filter = {
+                conversationId,
+                context: librechatDataProvider.FileContext.execute_code,
+                messageId: { $exists: true, $in: messageIds },
+                'metadata.fileIdentifier': { $exists: true },
+            };
+            const selectFields = { text: 0 };
+            const sortOptions = { createdAt: 1 };
+            const results = await getFiles(filter, sortOptions, selectFields);
+            return results !== null && results !== void 0 ? results : [];
+        }
+        catch (error) {
+            logger$1.error('[getCodeGeneratedFiles] Error retrieving code generated files:', error);
+            return [];
+        }
+    }
+    /**
+     * Retrieves user-uploaded execute_code files (not code-generated) by their file IDs.
+     * These are files with fileIdentifier metadata but context is NOT execute_code (e.g., agents or message_attachment).
+     * File IDs should be collected from message.files arrays in the current thread.
+     * @param fileIds - Array of file IDs to fetch (from message.files in the thread)
+     * @returns User-uploaded execute_code files
+     */
+    async function getUserCodeFiles(fileIds) {
+        if (!fileIds || fileIds.length === 0) {
+            return [];
+        }
+        try {
+            const filter = {
+                file_id: { $in: fileIds },
+                context: { $ne: librechatDataProvider.FileContext.execute_code },
+                'metadata.fileIdentifier': { $exists: true },
+            };
+            const selectFields = { text: 0 };
+            const sortOptions = { createdAt: 1 };
+            const results = await getFiles(filter, sortOptions, selectFields);
+            return results !== null && results !== void 0 ? results : [];
+        }
+        catch (error) {
+            logger$1.error('[getUserCodeFiles] Error retrieving user code files:', error);
+            return [];
+        }
+    }
+    /**
+     * Atomically claims a file_id for a code-execution output by compound key.
+     * Uses $setOnInsert so concurrent calls for the same (filename, conversationId)
+     * converge on a single record instead of creating duplicates.
+     */
+    async function claimCodeFile(data) {
+        const File = mongoose.models.File;
+        const result = await File.findOneAndUpdate({
+            filename: data.filename,
+            conversationId: data.conversationId,
+            context: librechatDataProvider.FileContext.execute_code,
+        }, { $setOnInsert: { file_id: data.file_id, user: data.user } }, { upsert: true, new: true }).lean();
+        if (!result) {
+            throw new Error(`[claimCodeFile] Failed to claim file "${data.filename}" for conversation ${data.conversationId}`);
+        }
+        return result;
+    }
     /**
      * Creates a new file with a TTL of 1 hour.
      * @param data - The file data to be created, must contain file_id
@@ -4608,6 +4765,9 @@ function createFileMethods(mongoose) {
         findFileById,
         getFiles,
         getToolFilesByIds,
+        getCodeGeneratedFiles,
+        getUserCodeFiles,
+        claimCodeFile,
         createFile,
         updateFile,
         updateFileUsage,
@@ -4966,6 +5126,139 @@ function createAgentCategoryMethods(mongoose) {
     };
 }
 
+const API_KEY_PREFIX = 'sk-';
+const API_KEY_LENGTH = 32;
+function createAgentApiKeyMethods(mongoose) {
+    async function generateApiKey() {
+        const randomPart = await getRandomValues(API_KEY_LENGTH);
+        const key = `${API_KEY_PREFIX}${randomPart}`;
+        const keyHash = await hashToken(key);
+        const keyPrefix = key.slice(0, 8);
+        return { key, keyHash, keyPrefix };
+    }
+    async function createAgentApiKey(data) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const { key, keyHash, keyPrefix } = await generateApiKey();
+            const apiKeyDoc = await AgentApiKey.create({
+                userId: data.userId,
+                name: data.name,
+                keyHash,
+                keyPrefix,
+                expiresAt: data.expiresAt || undefined,
+            });
+            return {
+                id: apiKeyDoc._id.toString(),
+                name: apiKeyDoc.name,
+                keyPrefix,
+                key,
+                createdAt: apiKeyDoc.createdAt,
+                expiresAt: apiKeyDoc.expiresAt,
+            };
+        }
+        catch (error) {
+            logger$1.error('[createAgentApiKey] Error creating API key:', error);
+            throw error;
+        }
+    }
+    async function validateAgentApiKey(apiKey) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const keyHash = await hashToken(apiKey);
+            const keyDoc = (await AgentApiKey.findOne({ keyHash }).lean());
+            if (!keyDoc) {
+                return null;
+            }
+            if (keyDoc.expiresAt && new Date(keyDoc.expiresAt) < new Date()) {
+                return null;
+            }
+            await AgentApiKey.updateOne({ _id: keyDoc._id }, { $set: { lastUsedAt: new Date() } });
+            return {
+                userId: keyDoc.userId,
+                keyId: keyDoc._id,
+            };
+        }
+        catch (error) {
+            logger$1.error('[validateAgentApiKey] Error validating API key:', error);
+            return null;
+        }
+    }
+    async function listAgentApiKeys(userId) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const keys = (await AgentApiKey.find({ userId })
+                .sort({ createdAt: -1 })
+                .lean());
+            return keys.map((key) => ({
+                id: key._id.toString(),
+                name: key.name,
+                keyPrefix: key.keyPrefix,
+                lastUsedAt: key.lastUsedAt,
+                expiresAt: key.expiresAt,
+                createdAt: key.createdAt,
+            }));
+        }
+        catch (error) {
+            logger$1.error('[listAgentApiKeys] Error listing API keys:', error);
+            throw error;
+        }
+    }
+    async function deleteAgentApiKey(keyId, userId) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const result = await AgentApiKey.deleteOne({ _id: keyId, userId });
+            return result.deletedCount > 0;
+        }
+        catch (error) {
+            logger$1.error('[deleteAgentApiKey] Error deleting API key:', error);
+            throw error;
+        }
+    }
+    async function deleteAllAgentApiKeys(userId) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const result = await AgentApiKey.deleteMany({ userId });
+            return result.deletedCount;
+        }
+        catch (error) {
+            logger$1.error('[deleteAllAgentApiKeys] Error deleting all API keys:', error);
+            throw error;
+        }
+    }
+    async function getAgentApiKeyById(keyId, userId) {
+        try {
+            const AgentApiKey = mongoose.models.AgentApiKey;
+            const keyDoc = (await AgentApiKey.findOne({
+                _id: keyId,
+                userId,
+            }).lean());
+            if (!keyDoc) {
+                return null;
+            }
+            return {
+                id: keyDoc._id.toString(),
+                name: keyDoc.name,
+                keyPrefix: keyDoc.keyPrefix,
+                lastUsedAt: keyDoc.lastUsedAt,
+                expiresAt: keyDoc.expiresAt,
+                createdAt: keyDoc.createdAt,
+            };
+        }
+        catch (error) {
+            logger$1.error('[getAgentApiKeyById] Error getting API key:', error);
+            throw error;
+        }
+    }
+    return {
+        createAgentApiKey,
+        validateAgentApiKey,
+        listAgentApiKeys,
+        deleteAgentApiKey,
+        deleteAllAgentApiKeys,
+        getAgentApiKeyById,
+    };
+}
+
 const NORMALIZED_LIMIT_DEFAULT = 20;
 const MAX_CREATE_RETRIES = 5;
 const RETRY_BASE_DELAY_MS = 25;
@@ -5466,6 +5759,27 @@ function createAccessRoleMethods(mongoose) {
                 resourceType: librechatDataProvider.ResourceType.MCPSERVER,
                 permBits: exports.RoleBits.OWNER,
             },
+            {
+                accessRoleId: librechatDataProvider.AccessRoleIds.REMOTE_AGENT_VIEWER,
+                name: 'com_ui_remote_agent_role_viewer',
+                description: 'com_ui_remote_agent_role_viewer_desc',
+                resourceType: librechatDataProvider.ResourceType.REMOTE_AGENT,
+                permBits: exports.RoleBits.VIEWER,
+            },
+            {
+                accessRoleId: librechatDataProvider.AccessRoleIds.REMOTE_AGENT_EDITOR,
+                name: 'com_ui_remote_agent_role_editor',
+                description: 'com_ui_remote_agent_role_editor_desc',
+                resourceType: librechatDataProvider.ResourceType.REMOTE_AGENT,
+                permBits: exports.RoleBits.EDITOR,
+            },
+            {
+                accessRoleId: librechatDataProvider.AccessRoleIds.REMOTE_AGENT_OWNER,
+                name: 'com_ui_remote_agent_role_owner',
+                description: 'com_ui_remote_agent_role_owner_desc',
+                resourceType: librechatDataProvider.ResourceType.REMOTE_AGENT,
+                permBits: exports.RoleBits.OWNER,
+            },
         ];
         const result = {};
         for (const role of defaultRoles) {
@@ -6703,6 +7017,77 @@ function createShareMethods(mongoose) {
     };
 }
 
+function createTransactionMethods(mongoose) {
+    async function updateBalance({ user, incrementValue, setValues }) {
+        var _a;
+        const maxRetries = 10;
+        let delay = 50;
+        let lastError = null;
+        const Balance = mongoose.models.Balance;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const currentBalanceDoc = await Balance.findOne({ user }).lean();
+                const currentCredits = (_a = currentBalanceDoc === null || currentBalanceDoc === void 0 ? void 0 : currentBalanceDoc.tokenCredits) !== null && _a !== void 0 ? _a : 0;
+                const newCredits = Math.max(0, currentCredits + incrementValue);
+                const updatePayload = {
+                    $set: {
+                        tokenCredits: newCredits,
+                        ...(setValues !== null && setValues !== void 0 ? setValues : {}),
+                    },
+                };
+                if (currentBalanceDoc) {
+                    const updatedBalance = await Balance.findOneAndUpdate({ user, tokenCredits: currentCredits }, updatePayload, { new: true }).lean();
+                    if (updatedBalance) {
+                        return updatedBalance;
+                    }
+                    lastError = new Error(`Concurrency conflict for user ${user} on attempt ${attempt}.`);
+                }
+                else {
+                    try {
+                        const updatedBalance = await Balance.findOneAndUpdate({ user }, updatePayload, {
+                            upsert: true,
+                            new: true,
+                        }).lean();
+                        if (updatedBalance) {
+                            return updatedBalance;
+                        }
+                        lastError = new Error(`Upsert race condition suspected for user ${user} on attempt ${attempt}.`);
+                    }
+                    catch (error) {
+                        if (error instanceof Error &&
+                            'code' in error &&
+                            error.code === 11000) {
+                            lastError = error;
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                logger$1.error(`[updateBalance] Error during attempt ${attempt} for user ${user}:`, error);
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+            if (attempt < maxRetries) {
+                const jitter = Math.random() * delay * 0.5;
+                await new Promise((resolve) => setTimeout(resolve, delay + jitter));
+                delay = Math.min(delay * 2, 2000);
+            }
+        }
+        logger$1.error(`[updateBalance] Failed to update balance for user ${user} after ${maxRetries} attempts.`);
+        throw (lastError !== null && lastError !== void 0 ? lastError : new Error(`Failed to update balance for user ${user} after maximum retries due to persistent conflicts.`));
+    }
+    /** Bypasses document middleware; all computed fields must be pre-calculated before calling. */
+    async function bulkInsertTransactions(docs) {
+        const Transaction = mongoose.models.Transaction;
+        if (docs.length) {
+            await Transaction.insertMany(docs);
+        }
+    }
+    return { updateBalance, bulkInsertTransactions };
+}
+
 /**
  * Creates all database methods for all collections
  * @param mongoose - Mongoose instance
@@ -6717,19 +7102,23 @@ function createMethods(mongoose) {
         ...createFileMethods(mongoose),
         ...createMemoryMethods(mongoose),
         ...createAgentCategoryMethods(mongoose),
+        ...createAgentApiKeyMethods(mongoose),
         ...createMCPServerMethods(mongoose),
         ...createAccessRoleMethods(mongoose),
         ...createUserGroupMethods(mongoose),
         ...createAclEntryMethods(mongoose),
         ...createShareMethods(mongoose),
         ...createPluginAuthMethods(mongoose),
+        ...createTransactionMethods(mongoose),
     };
 }
 
 exports.AppService = AppService;
+exports.CANCEL_RATE = CANCEL_RATE;
 exports.DEFAULT_REFRESH_TOKEN_EXPIRY = DEFAULT_REFRESH_TOKEN_EXPIRY;
 exports.DEFAULT_SESSION_EXPIRY = DEFAULT_SESSION_EXPIRY;
 exports.actionSchema = Action;
+exports.agentApiKeySchema = agentApiKeySchema;
 exports.agentCategorySchema = agentCategorySchema;
 exports.agentSchema = agentSchema;
 exports.agentsConfigSetup = agentsConfigSetup;