@librechat/data-schemas 0.0.34 → 0.0.36

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { EModelEndpoint, agentsEndpointSchema, memorySchema, removeNullishValues, SafeSearchTypes, normalizeEndpointName, defaultAssistantsVersion, Capabilities, assistantEndpointSchema, validateAzureGroups, mapModelToAzureConfig, extractEnvVariable, envVarRegex, OCRStrategy, getConfigDefaults, PermissionBits, FileSources, Constants, PermissionTypes, Permissions, SystemRoles, parseTextParts, ResourceType, PrincipalType, PrincipalModel, roleDefaults, ErrorTypes, EToolResources, FileContext, AccessRoleIds } from 'librechat-data-provider';
+import { EModelEndpoint, agentsEndpointSchema, memorySchema, removeNullishValues, SafeSearchTypes, normalizeEndpointName, defaultAssistantsVersion, Capabilities, assistantEndpointSchema, validateAzureGroups, mapModelToAzureConfig, extractEnvVariable, envVarRegex, OCRStrategy, getConfigDefaults, PermissionBits, FileSources, FileContext, Constants, PermissionTypes, Permissions, SystemRoles, parseTextParts, ResourceType, PrincipalType, PrincipalModel, roleDefaults, ErrorTypes, EToolResources, AccessRoleIds } from 'librechat-data-provider';
 import winston from 'winston';
 import 'winston-daily-rotate-file';
 import { klona } from 'klona';
@@ -1460,12 +1460,57 @@ const agentSchema = new Schema({
         default: [],
         index: true,
     },
+    /** Per-tool configuration (defer_loading, allowed_callers) */
+    tool_options: {
+        type: Schema.Types.Mixed,
+        default: undefined,
+    },
 }, {
     timestamps: true,
 });
 agentSchema.index({ updatedAt: -1, _id: 1 });
 agentSchema.index({ 'edges.to': 1 });
 
+const agentApiKeySchema = new 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 Schema({
     value: {
         type: String,
@@ -1728,6 +1773,9 @@ const conversationPreset = {
     thinkingBudget: {
         type: Number,
     },
+    effort: {
+        type: String,
+    },
     system: {
         type: String,
     },
@@ -1854,6 +1902,10 @@ const file = new Schema({
         ref: 'Conversation',
         index: true,
     },
+    messageId: {
+        type: String,
+        index: true,
+    },
     file_id: {
         type: String,
         index: true,
@@ -1917,6 +1969,7 @@ const file = new Schema({
     timestamps: true,
 });
 file.index({ createdAt: 1, updatedAt: 1 });
+file.index({ filename: 1, conversationId: 1, context: 1 }, { unique: true, partialFilterExpression: { context: FileContext.execute_code } });
 
 const keySchema = new Schema({
     userId: {
@@ -2294,6 +2347,12 @@ const rolePermissionsSchema = new Schema({
         [Permissions.SHARE]: { type: Boolean },
         [Permissions.SHARE_PUBLIC]: { type: Boolean },
     },
+    [PermissionTypes.REMOTE_AGENTS]: {
+        [Permissions.USE]: { type: Boolean },
+        [Permissions.CREATE]: { type: Boolean },
+        [Permissions.SHARE]: { type: Boolean },
+        [Permissions.SHARE_PUBLIC]: { type: Boolean },
+    },
 }, { _id: false });
 const roleSchema = new Schema({
     name: { type: String, required: true, unique: true, index: true },
@@ -2868,8 +2927,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();
@@ -2894,7 +2953,7 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, syncOptions, }) =>
             while (hasMore) {
                 const query = {
                     expiredAt: null,
-                    _meiliIndex: false,
+                    _meiliIndex: { $ne: true },
                 };
                 try {
                     const documents = await this.find(query)
@@ -2972,7 +3031,11 @@ const createMeiliMongooseModel = ({ index, attributesToIndex, syncOptions, }) =>
                         await index.deleteDocuments(toDelete.map(String));
                         logger.debug(`[cleanupMeiliIndex] Deleted ${toDelete.length} orphaned documents`);
                     }
-                    offset += batchSize;
+                    // if fetch documents request returns less documents than limit, all documents are processed
+                    if (batch.results.length < batchSize) {
+                        break;
+                    }
+                    offset += batchSize - toDelete.length;
                     // Add delay between batches
                     if (delayMs > 0) {
                         await new Promise((resolve) => setTimeout(resolve, delayMs));
@@ -3353,6 +3416,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
  */
@@ -3516,7 +3583,7 @@ const accessRoleSchema = new Schema({
     description: String,
     resourceType: {
         type: String,
-        enum: ['agent', 'project', 'file', 'promptGroup', 'mcpServer'],
+        enum: ['agent', 'project', 'file', 'promptGroup', 'mcpServer', 'remoteAgent'],
         required: true,
         default: 'agent',
     },
@@ -3616,6 +3683,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),
@@ -4429,30 +4497,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(EToolResources.context)) {
-                (_a = filter.$or) === null || _a === void 0 ? void 0 : _a.push({ text: { $exists: true, $ne: null }, context: FileContext.agents });
+                orConditions.push({ text: { $exists: true, $ne: null }, context: FileContext.agents });
             }
             if (toolResourceSet.has(EToolResources.file_search)) {
-                (_b = filter.$or) === null || _b === void 0 ? void 0 : _b.push({ embedded: true });
+                orConditions.push({ embedded: true });
             }
-            if (toolResourceSet.has(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: FileContext.execute_code },
+                $or: orConditions,
+            };
             const selectFields = { text: 0 };
             const sortOptions = { updatedAt: -1 };
             const results = await getFiles(filter, sortOptions, selectFields);
@@ -4463,6 +4534,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: 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: 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: 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
@@ -4602,6 +4758,9 @@ function createFileMethods(mongoose) {
         findFileById,
         getFiles,
         getToolFilesByIds,
+        getCodeGeneratedFiles,
+        getUserCodeFiles,
+        claimCodeFile,
         createFile,
         updateFile,
         updateFileUsage,
@@ -4960,6 +5119,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;
@@ -5460,6 +5752,27 @@ function createAccessRoleMethods(mongoose) {
                 resourceType: ResourceType.MCPSERVER,
                 permBits: RoleBits.OWNER,
             },
+            {
+                accessRoleId: AccessRoleIds.REMOTE_AGENT_VIEWER,
+                name: 'com_ui_remote_agent_role_viewer',
+                description: 'com_ui_remote_agent_role_viewer_desc',
+                resourceType: ResourceType.REMOTE_AGENT,
+                permBits: RoleBits.VIEWER,
+            },
+            {
+                accessRoleId: AccessRoleIds.REMOTE_AGENT_EDITOR,
+                name: 'com_ui_remote_agent_role_editor',
+                description: 'com_ui_remote_agent_role_editor_desc',
+                resourceType: ResourceType.REMOTE_AGENT,
+                permBits: RoleBits.EDITOR,
+            },
+            {
+                accessRoleId: AccessRoleIds.REMOTE_AGENT_OWNER,
+                name: 'com_ui_remote_agent_role_owner',
+                description: 'com_ui_remote_agent_role_owner_desc',
+                resourceType: ResourceType.REMOTE_AGENT,
+                permBits: RoleBits.OWNER,
+            },
         ];
         const result = {};
         for (const role of defaultRoles) {
@@ -6711,6 +7024,7 @@ function createMethods(mongoose) {
         ...createFileMethods(mongoose),
         ...createMemoryMethods(mongoose),
         ...createAgentCategoryMethods(mongoose),
+        ...createAgentApiKeyMethods(mongoose),
         ...createMCPServerMethods(mongoose),
         ...createAccessRoleMethods(mongoose),
         ...createUserGroupMethods(mongoose),
@@ -6720,5 +7034,5 @@ function createMethods(mongoose) {
     };
 }
 
-export { AppService, DEFAULT_REFRESH_TOKEN_EXPIRY, DEFAULT_SESSION_EXPIRY, RoleBits, Action as actionSchema, agentCategorySchema, agentSchema, agentsConfigSetup, assistantSchema, balanceSchema, bannerSchema, categoriesSchema, conversationTag as conversationTagSchema, convoSchema, createMethods, createModels, decrypt, decryptV2, decryptV3, defaultVertexModels, encrypt, encryptV2, encryptV3, file as fileSchema, getRandomValues, getTransactionSupport, getWebSearchKeys, groupSchema, hashBackupCode, hashToken, keySchema, loadDefaultInterface, loadTurnstileConfig, loadWebSearchConfig, logger$1 as logger, logger as meiliLogger, MemoryEntrySchema as memorySchema, messageSchema, pluginAuthSchema, presetSchema, processModelSpecs, projectSchema, promptGroupSchema, promptSchema, roleSchema, sessionSchema, shareSchema, signPayload, supportsTransactions, tokenSchema, toolCallSchema, transactionSchema, userSchema, validateVertexConfig, vertexConfigSetup, webSearchAuth, webSearchKeys };
+export { AppService, DEFAULT_REFRESH_TOKEN_EXPIRY, DEFAULT_SESSION_EXPIRY, RoleBits, Action as actionSchema, agentApiKeySchema, agentCategorySchema, agentSchema, agentsConfigSetup, assistantSchema, balanceSchema, bannerSchema, categoriesSchema, conversationTag as conversationTagSchema, convoSchema, createMethods, createModels, decrypt, decryptV2, decryptV3, defaultVertexModels, encrypt, encryptV2, encryptV3, file as fileSchema, getRandomValues, getTransactionSupport, getWebSearchKeys, groupSchema, hashBackupCode, hashToken, keySchema, loadDefaultInterface, loadTurnstileConfig, loadWebSearchConfig, logger$1 as logger, logger as meiliLogger, MemoryEntrySchema as memorySchema, messageSchema, pluginAuthSchema, presetSchema, processModelSpecs, projectSchema, promptGroupSchema, promptSchema, roleSchema, sessionSchema, shareSchema, signPayload, supportsTransactions, tokenSchema, toolCallSchema, transactionSchema, userSchema, validateVertexConfig, vertexConfigSetup, webSearchAuth, webSearchKeys };
 //# sourceMappingURL=index.es.js.map