🔧 fix: Merge and Rebase Conflicts

- Move AgentCategory from api/models to @packages/data-schemas structure
  - Add schema, types, methods, and model following codebase conventions
  - Implement auto-seeding of default categories during AppService startup
  - Update marketplace controller to use new data-schemas methods
  - Remove old model file and standalone seed script

refactor: unify agent marketplace to single endpoint with cursor pagination

  - Replace multiple marketplace routes with unified /marketplace endpoint
  - Add query string controls: category, search, limit, cursor, promoted, requiredPermission
  - Implement cursor-based pagination replacing page-based system
  - Integrate ACL permissions for proper access control
  - Fix ObjectId constructor error in Agent model
  - Update React components to use unified useGetMarketplaceAgentsQuery hook
  - Enhance type safety and remove deprecated useDynamicAgentQuery
  - Update tests for new marketplace architecture
  -Known issues:
  see more button after category switching + Unit tests

feat: add icon property to ProcessedAgentCategory interface

- Add useMarketplaceAgentsInfiniteQuery and useGetAgentCategoriesQuery to client/src/data-provider/Agents/
  - Replace manual pagination in AgentGrid with infinite query pattern
  - Update imports to use local data provider instead of librechat-data-provider
  - Add proper permission handling with PERMISSION_BITS.VIEW/EDIT constants
  - Improve agent access control by adding requiredPermission validation in backend
  - Remove manual cursor/state management in favor of infinite query built-ins
  - Maintain existing search and category filtering functionality

refactor: consolidate agent marketplace endpoints into main agents API and improve data management consistency

  - Remove dedicated marketplace controller and routes, merging functionality into main agents v1 API
  - Add countPromotedAgents function to Agent model for promoted agents count
  - Enhance getListAgents handler with marketplace filtering (category, search, promoted status)
  - Move getAgentCategories from marketplace to v1 controller with same functionality
  - Update agent mutations to invalidate marketplace queries and handle multiple permission levels
  - Improve cache management by updating all agent query variants (VIEW/EDIT permissions)
  - Consolidate agent data access patterns for better maintainability and consistency
  - Remove duplicate marketplace route definitions and middleware

selected view only agents injected in the drop down

fix: remove minlength validation for support contact name in agent schema

feat: add validation and error messages for agent name in AgentConfig and AgentPanel

fix: update agent permission check logic in AgentPanel to simplify condition

Fix linting WIP

Fix Unit tests WIP

ESLint fixes

eslint fix

refactor: enhance isDuplicateVersion function in Agent model for improved comparison logic

- Introduced handling for undefined/null values in array and object comparisons.
- Normalized array comparisons to treat undefined/null as empty arrays.
- Added deep comparison for objects and improved handling of primitive values.
- Enhanced projectIds comparison to ensure consistent MongoDB ObjectId handling.

refactor: remove redundant properties from IAgent interface in agent schema

chore: update localization for agent detail component and clean up imports

ci: update access middleware tests

chore: remove unused PermissionTypes import from Role model

ci: update AclEntry model tests

ci: update button accessibility labels in AgentDetail tests

refactor: update exhaustive dep. lint warning

api/server/controllers/agents/marketplace.js

@@ -1,255 +0,0 @@
-const AgentCategory = require('~/models/AgentCategory');
-const mongoose = require('mongoose');
-const { logger } = require('~/config');
-
-// Get the Agent model
-const Agent = mongoose.model('Agent');
-
-// Default page size for agent browsing
-const DEFAULT_PAGE_SIZE = 6;
-
-/**
- * Common pagination utility for agent queries
- *
- * @param {Object} filter - MongoDB filter object
- * @param {number} page - Page number (1-based)
- * @param {number} limit - Items per page
- * @returns {Promise<Object>} Paginated results with agents and pagination info
- */
-const paginateAgents = async (filter, page = 1, limit = DEFAULT_PAGE_SIZE) => {
-  const skip = (page - 1) * limit;
-
-  // Get total count for pagination
-  const total = await Agent.countDocuments(filter);
-
-  // Get agents with pagination
-  const agents = await Agent.find(filter)
-    .select('id name description avatar category support_contact authorName')
-    .sort({ updatedAt: -1 })
-    .skip(skip)
-    .limit(limit)
-    .lean();
-
-  // Calculate if there are more agents to load
-  const hasMore = total > page * limit;
-
-  return {
-    agents,
-    pagination: {
-      current: page,
-      hasMore,
-      total,
-    },
-  };
-};
-
-/**
- * Get promoted/top picks agents with pagination
- * Can also return all agents when showAll=true parameter is provided
- *
- * @param {Object} req - Express request object
- * @param {Object} res - Express response object
- */
-const getPromotedAgents = async (req, res) => {
-  try {
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || DEFAULT_PAGE_SIZE;
-
-    // Check if this is a request for "all" agents via query parameter
-    const showAllAgents = req.query.showAll === 'true';
-
-    // Base filter for shared agents only
-    const filter = {
-      projectIds: { $exists: true, $ne: [] }, // Only get shared agents
-    };
-
-    // Only add promoted filter if not requesting all agents
-    if (!showAllAgents) {
-      filter.is_promoted = true; // Only get promoted agents
-    }
-
-    const result = await paginateAgents(filter, page, limit);
-    res.status(200).json(result);
-  } catch (error) {
-    logger.error('[/Agents/Marketplace] Error fetching promoted agents:', error);
-    res.status(500).json({
-      error: 'Failed to fetch promoted agents',
-      userMessage: 'Unable to load agents. Please try refreshing the page.',
-      suggestion: 'Try refreshing the page or check your network connection',
-    });
-  }
-};
-
-/**
- * Get agents by category with pagination
- *
- * @param {Object} req - Express request object
- * @param {Object} res - Express response object
- */
-const getAgentsByCategory = async (req, res) => {
-  try {
-    const { category } = req.params;
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || DEFAULT_PAGE_SIZE;
-
-    const filter = {
-      category,
-      projectIds: { $exists: true, $ne: [] }, // Only get shared agents
-    };
-
-    const result = await paginateAgents(filter, page, limit);
-
-    // Get category description from database
-    const categoryDoc = await AgentCategory.findOne({ value: category, isActive: true });
-    const categoryInfo = {
-      name: category,
-      description: categoryDoc?.description || '',
-      total: result.pagination.total,
-    };
-
-    res.status(200).json({
-      ...result,
-      category: categoryInfo,
-    });
-  } catch (error) {
-    logger.error(
-      `[/Agents/Marketplace] Error fetching agents for category ${req.params.category}:`,
-      error,
-    );
-    res.status(500).json({
-      error: 'Failed to fetch agents by category',
-      userMessage: `Unable to load agents for this category. Please try a different category.`,
-      suggestion: 'Try selecting a different category or refresh the page',
-    });
-  }
-};
-
-/**
- * Search agents with filters
- *
- * @param {Object} req - Express request object
- * @param {Object} res - Express response object
- */
-const searchAgents = async (req, res) => {
-  try {
-    const { q, category } = req.query;
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || DEFAULT_PAGE_SIZE;
-
-    if (!q || q.trim() === '') {
-      return res.status(400).json({
-        error: 'Search query is required',
-        userMessage: 'Please enter a search term to find agents',
-        suggestion: 'Enter a search term to find agents by name or description',
-      });
-    }
-
-    // Build search filter
-    const filter = {
-      projectIds: { $exists: true, $ne: [] }, // Only get shared agents
-      $or: [
-        { name: { $regex: q, $options: 'i' } }, // Case-insensitive name search
-        { description: { $regex: q, $options: 'i' } },
-      ],
-    };
-
-    // Add category filter if provided
-    if (category && category !== 'all') {
-      filter.category = category;
-    }
-
-    const result = await paginateAgents(filter, page, limit);
-
-    res.status(200).json({
-      ...result,
-      query: q,
-    });
-  } catch (error) {
-    logger.error('[/Agents/Marketplace] Error searching agents:', error);
-    res.status(500).json({
-      error: 'Failed to search agents',
-      userMessage: 'Search is temporarily unavailable. Please try again.',
-      suggestion: 'Try a different search term or check your network connection',
-    });
-  }
-};
-
-/**
- * Get all agent categories with counts
- *
- * @param {Object} _req - Express request object (unused)
- * @param {Object} res - Express response object
- */
-const getAgentCategories = async (_req, res) => {
-  try {
-    // Get categories with agent counts from database
-    const categories = await AgentCategory.getCategoriesWithCounts();
-
-    // Get count of promoted agents for Top Picks
-    const promotedCount = await Agent.countDocuments({
-      projectIds: { $exists: true, $ne: [] },
-      is_promoted: true,
-    });
-
-    // Convert to marketplace format (TCategory structure)
-    const formattedCategories = categories.map((category) => ({
-      value: category.value,
-      label: category.label,
-      count: category.agentCount,
-      description: category.description,
-    }));
-
-    // Add promoted category if agents exist
-    if (promotedCount > 0) {
-      formattedCategories.unshift({
-        value: 'promoted',
-        label: 'Promoted',
-        count: promotedCount,
-        description: 'Our recommended agents',
-      });
-    }
-
-    // Get total count of all shared agents for "All" category
-    const totalAgents = await Agent.countDocuments({
-      projectIds: { $exists: true, $ne: [] },
-    });
-
-    // Add "All" category at the end
-    formattedCategories.push({
-      value: 'all',
-      label: 'All',
-      count: totalAgents,
-      description: 'All available agents',
-    });
-
-    res.status(200).json(formattedCategories);
-  } catch (error) {
-    logger.error('[/Agents/Marketplace] Error fetching agent categories:', error);
-    res.status(500).json({
-      error: 'Failed to fetch agent categories',
-      userMessage: 'Unable to load categories. Please refresh the page.',
-      suggestion: 'Try refreshing the page or check your network connection',
-    });
-  }
-};
-
-/**
- * Get all agents with pagination (for "all" category)
- * This is an alias for getPromotedAgents with showAll=true for backwards compatibility
- *
- * @param {Object} req - Express request object
- * @param {Object} res - Express response object
- */
-const getAllAgents = async (req, res) => {
-  // Set showAll parameter and delegate to getPromotedAgents
-  req.query.showAll = 'true';
-  return getPromotedAgents(req, res);
-};
-
-module.exports = {
-  getPromotedAgents,
-  getAgentsByCategory,
-  searchAgents,
-  getAgentCategories,
-  getAllAgents,
-};

api/server/controllers/agents/v1.js

@@ -17,6 +17,8 @@ const {
   updateAgent,
   deleteAgent,
   getListAgentsByAccess,
+  countPromotedAgents,
+  revertAgentVersion,
 } = require('~/models/Agent');
 const {
   grantPermission,
@@ -30,8 +32,8 @@ const { refreshS3Url } = require('~/server/services/Files/S3/crud');
 const { filterFile } = require('~/server/services/Files/process');
 const { updateAction, getActions } = require('~/models/Action');
 const { getCachedTools } = require('~/server/services/Config');
-const { revertAgentVersion } = require('~/models/Agent');
 const { deleteFileByFilter } = require('~/models/File');
+const { getCategoriesWithCounts } = require('~/models');
 
 const systemTools = {
   [Tools.execute_code]: true,
@@ -399,12 +401,43 @@ const deleteAgentHandler = async (req, res) => {
 const getListAgentsHandler = async (req, res) => {
   try {
     const userId = req.user.id;
+    const { category, search, limit, cursor, promoted } = req.query;
+    let requiredPermission = req.query.requiredPermission;
+    if (typeof requiredPermission === 'string') {
+      requiredPermission = parseInt(requiredPermission, 10);
+      if (isNaN(requiredPermission)) {
+        requiredPermission = PermissionBits.VIEW;
+      }
+    } else if (typeof requiredPermission !== 'number') {
+      requiredPermission = PermissionBits.VIEW;
+    }
+    // Base filter
+    const filter = {};
 
+    // Handle category filter - only apply if category is defined
+    if (category !== undefined && category.trim() !== '') {
+      filter.category = category;
+    }
+
+    // Handle promoted filter - only from query param
+    if (promoted === '1') {
+      filter.is_promoted = true;
+    } else if (promoted === '0') {
+      filter.is_promoted = { $ne: true };
+    }
+
+    // Handle search filter
+    if (search && search.trim() !== '') {
+      filter.$or = [
+        { name: { $regex: search.trim(), $options: 'i' } },
+        { description: { $regex: search.trim(), $options: 'i' } },
+      ];
+    }
     // Get agent IDs the user has VIEW access to via ACL
     const accessibleIds = await findAccessibleResources({
       userId,
       resourceType: 'agent',
-      requiredPermissions: PermissionBits.VIEW,
+      requiredPermissions: requiredPermission,
     });
     const publiclyAccessibleIds = await findPubliclyAccessibleResources({
       resourceType: 'agent',
@@ -413,7 +446,9 @@ const getListAgentsHandler = async (req, res) => {
     // Use the new ACL-aware function
     const data = await getListAgentsByAccess({
       accessibleIds,
-      otherParams: {}, // Can add query params here if needed
+      otherParams: filter,
+      limit,
+      after: cursor,
     });
     if (data?.data?.length) {
       data.data = data.data.map((agent) => {
@@ -589,7 +624,48 @@ const revertAgentVersionHandler = async (req, res) => {
     res.status(500).json({ error: error.message });
   }
 };
+/**
+ * Get all agent categories with counts
+ *
+ * @param {Object} _req - Express request object (unused)
+ * @param {Object} res - Express response object
+ */
+const getAgentCategories = async (_req, res) => {
+  try {
+    const categories = await getCategoriesWithCounts();
+    const promotedCount = await countPromotedAgents();
+    const formattedCategories = categories.map((category) => ({
+      value: category.value,
+      label: category.label,
+      count: category.agentCount,
+      description: category.description,
+    }));
 
+    if (promotedCount > 0) {
+      formattedCategories.unshift({
+        value: 'promoted',
+        label: 'Promoted',
+        count: promotedCount,
+        description: 'Our recommended agents',
+      });
+    }
+
+    formattedCategories.push({
+      value: 'all',
+      label: 'All',
+      description: 'All available agents',
+    });
+
+    res.status(200).json(formattedCategories);
+  } catch (error) {
+    logger.error('[/Agents/Marketplace] Error fetching agent categories:', error);
+    res.status(500).json({
+      error: 'Failed to fetch agent categories',
+      userMessage: 'Unable to load categories. Please refresh the page.',
+      suggestion: 'Try refreshing the page or check your network connection',
+    });
+  }
+};
 module.exports = {
   createAgent: createAgentHandler,
   getAgent: getAgentHandler,
@@ -599,4 +675,5 @@ module.exports = {
   getListAgents: getListAgentsHandler,
   uploadAgentAvatar: uploadAgentAvatarHandler,
   revertAgentVersion: revertAgentVersionHandler,
+  getAgentCategories,
 };

api/server/middleware/roles/access.spec.js

@@ -1,17 +1,31 @@
 const mongoose = require('mongoose');
 const { MongoMemoryServer } = require('mongodb-memory-server');
-const { checkAccess, generateCheckAccess } = require('./access');
+const { checkAccess, generateCheckAccess } = require('@librechat/api');
 const { PermissionTypes, Permissions } = require('librechat-data-provider');
+const { getRoleByName } = require('~/models/Role');
 const { Role } = require('~/db/models');
 
-// Mock only the logger
-jest.mock('~/config', () => ({
+// Mock the logger from @librechat/data-schemas
+jest.mock('@librechat/data-schemas', () => ({
+  ...jest.requireActual('@librechat/data-schemas'),
   logger: {
     warn: jest.fn(),
     error: jest.fn(),
+    info: jest.fn(),
+    debug: jest.fn(),
   },
 }));
 
+// Mock the cache to use a simple in-memory implementation
+const mockCache = new Map();
+jest.mock('~/cache/getLogStores', () => {
+  return jest.fn(() => ({
+    get: jest.fn(async (key) => mockCache.get(key)),
+    set: jest.fn(async (key, value) => mockCache.set(key, value)),
+    clear: jest.fn(async () => mockCache.clear()),
+  }));
+});
+
 describe('Access Middleware', () => {
   let mongoServer;
   let req, res, next;
@@ -29,33 +43,86 @@ describe('Access Middleware', () => {
 
   beforeEach(async () => {
     await mongoose.connection.dropDatabase();
+    mockCache.clear(); // Clear the cache between tests
 
     // Create test roles
     await Role.create({
       name: 'user',
       permissions: {
+        [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
+        [PermissionTypes.PROMPTS]: {
+          [Permissions.SHARED_GLOBAL]: false,
+          [Permissions.USE]: true,
+          [Permissions.CREATE]: true,
+        },
+        [PermissionTypes.MEMORIES]: {
+          [Permissions.USE]: true,
+          [Permissions.CREATE]: true,
+          [Permissions.UPDATE]: true,
+          [Permissions.READ]: true,
+          [Permissions.OPT_OUT]: true,
+        },
         [PermissionTypes.AGENTS]: {
           [Permissions.USE]: true,
           [Permissions.CREATE]: false,
           [Permissions.SHARED_GLOBAL]: false,
         },
+        [PermissionTypes.MULTI_CONVO]: { [Permissions.USE]: true },
+        [PermissionTypes.TEMPORARY_CHAT]: { [Permissions.USE]: true },
+        [PermissionTypes.RUN_CODE]: { [Permissions.USE]: true },
+        [PermissionTypes.WEB_SEARCH]: { [Permissions.USE]: true },
       },
     });
 
     await Role.create({
       name: 'admin',
       permissions: {
+        [PermissionTypes.BOOKMARKS]: { [Permissions.USE]: true },
+        [PermissionTypes.PROMPTS]: {
+          [Permissions.SHARED_GLOBAL]: true,
+          [Permissions.USE]: true,
+          [Permissions.CREATE]: true,
+        },
+        [PermissionTypes.MEMORIES]: {
+          [Permissions.USE]: true,
+          [Permissions.CREATE]: true,
+          [Permissions.UPDATE]: true,
+          [Permissions.READ]: true,
+          [Permissions.OPT_OUT]: true,
+        },
         [PermissionTypes.AGENTS]: {
           [Permissions.USE]: true,
           [Permissions.CREATE]: true,
           [Permissions.SHARED_GLOBAL]: true,
         },
+        [PermissionTypes.MULTI_CONVO]: { [Permissions.USE]: true },
+        [PermissionTypes.TEMPORARY_CHAT]: { [Permissions.USE]: true },
+        [PermissionTypes.RUN_CODE]: { [Permissions.USE]: true },
+        [PermissionTypes.WEB_SEARCH]: { [Permissions.USE]: true },
+      },
+    });
+
+    // Create limited role with no AGENTS permissions
+    await Role.create({
+      name: 'limited',
+      permissions: {
+        // Explicitly set AGENTS permissions to false
+        [PermissionTypes.AGENTS]: {
+          [Permissions.USE]: false,
+          [Permissions.CREATE]: false,
+          [Permissions.SHARED_GLOBAL]: false,
+        },
+        // Has permissions for other types
+        [PermissionTypes.PROMPTS]: {
+          [Permissions.USE]: true,
+        },
       },
     });
 
     req = {
       user: { id: 'user123', role: 'user' },
       body: {},
+      originalUrl: '/test',
     };
     res = {
       status: jest.fn().mockReturnThis(),
@@ -67,92 +134,114 @@ describe('Access Middleware', () => {
 
   describe('checkAccess', () => {
     test('should return false if user is not provided', async () => {
-      const result = await checkAccess(null, PermissionTypes.AGENTS, [Permissions.USE]);
+      const result = await checkAccess({
+        user: null,
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       expect(result).toBe(false);
     });
 
     test('should return true if user has required permission', async () => {
-      const result = await checkAccess(req.user, PermissionTypes.AGENTS, [Permissions.USE]);
+      const result = await checkAccess({
+        req: {},
+        user: { id: 'user123', role: 'user' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       expect(result).toBe(true);
     });
 
     test('should return false if user lacks required permission', async () => {
-      const result = await checkAccess(req.user, PermissionTypes.AGENTS, [Permissions.CREATE]);
+      const result = await checkAccess({
+        req: {},
+        user: { id: 'user123', role: 'user' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.CREATE],
+        getRoleByName,
+      });
       expect(result).toBe(false);
     });
 
     test('should return true if user has any of multiple permissions', async () => {
-      const result = await checkAccess(req.user, PermissionTypes.AGENTS, [
-        Permissions.USE,
-        Permissions.CREATE,
-      ]);
+      const result = await checkAccess({
+        req: {},
+        user: { id: 'user123', role: 'user' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.CREATE, Permissions.USE],
+        getRoleByName,
+      });
       expect(result).toBe(true);
     });
 
     test('should check body properties when permission is not directly granted', async () => {
-      // User role doesn't have CREATE permission, but bodyProps allows it
-      const bodyProps = {
-        [Permissions.CREATE]: ['agentId', 'name'],
-      };
-
-      const checkObject = { agentId: 'agent123' };
-
-      const result = await checkAccess(
-        req.user,
-        PermissionTypes.AGENTS,
-        [Permissions.CREATE],
-        bodyProps,
-        checkObject,
-      );
+      const req = { body: { id: 'agent123' } };
+      const result = await checkAccess({
+        req,
+        user: { id: 'user123', role: 'user' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.UPDATE],
+        bodyProps: {
+          [Permissions.UPDATE]: ['id'],
+        },
+        checkObject: req.body,
+        getRoleByName,
+      });
       expect(result).toBe(true);
     });
 
     test('should return false if role is not found', async () => {
-      req.user.role = 'nonexistent';
-      const result = await checkAccess(req.user, PermissionTypes.AGENTS, [Permissions.USE]);
+      const result = await checkAccess({
+        req: {},
+        user: { id: 'user123', role: 'nonexistent' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       expect(result).toBe(false);
     });
 
     test('should return false if role has no permissions for the requested type', async () => {
-      await Role.create({
-        name: 'limited',
-        permissions: {
-          // Explicitly set AGENTS permissions to false
-          [PermissionTypes.AGENTS]: {
-            [Permissions.USE]: false,
-            [Permissions.CREATE]: false,
-            [Permissions.SHARED_GLOBAL]: false,
-          },
-          // Has permissions for other types
-          [PermissionTypes.PROMPTS]: {
-            [Permissions.USE]: true,
-          },
-        },
+      const result = await checkAccess({
+        req: {},
+        user: { id: 'user123', role: 'limited' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
       });
-      req.user.role = 'limited';
-
-      const result = await checkAccess(req.user, PermissionTypes.AGENTS, [Permissions.USE]);
       expect(result).toBe(false);
     });
 
     test('should handle admin role with all permissions', async () => {
-      req.user.role = 'admin';
-
-      const createResult = await checkAccess(req.user, PermissionTypes.AGENTS, [
-        Permissions.CREATE,
-      ]);
+      const createResult = await checkAccess({
+        req: {},
+        user: { id: 'admin123', role: 'admin' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.CREATE],
+        getRoleByName,
+      });
       expect(createResult).toBe(true);
 
-      const shareResult = await checkAccess(req.user, PermissionTypes.AGENTS, [
-        Permissions.SHARED_GLOBAL,
-      ]);
+      const shareResult = await checkAccess({
+        req: {},
+        user: { id: 'admin123', role: 'admin' },
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.SHARED_GLOBAL],
+        getRoleByName,
+      });
       expect(shareResult).toBe(true);
     });
   });
 
   describe('generateCheckAccess', () => {
     test('should call next() when user has required permission', async () => {
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).toHaveBeenCalled();
@@ -160,7 +249,11 @@ describe('Access Middleware', () => {
     });
 
     test('should return 403 when user lacks permission', async () => {
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.CREATE]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.CREATE],
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).not.toHaveBeenCalled();
@@ -175,11 +268,12 @@ describe('Access Middleware', () => {
         [Permissions.CREATE]: ['agentId'],
       };
 
-      const middleware = generateCheckAccess(
-        PermissionTypes.AGENTS,
-        [Permissions.CREATE],
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.CREATE],
         bodyProps,
-      );
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).toHaveBeenCalled();
@@ -187,10 +281,16 @@ describe('Access Middleware', () => {
     });
 
     test('should handle database errors gracefully', async () => {
-      // Create a user with an invalid role that will cause getRoleByName to fail
-      req.user.role = { invalid: 'object' }; // This will cause an error when querying
+      // Mock getRoleByName to throw an error
+      const mockGetRoleByName = jest
+        .fn()
+        .mockRejectedValue(new Error('Database connection failed'));
 
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName: mockGetRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).not.toHaveBeenCalled();
@@ -203,11 +303,11 @@ describe('Access Middleware', () => {
     test('should work with multiple permission types', async () => {
       req.user.role = 'admin';
 
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [
-        Permissions.USE,
-        Permissions.CREATE,
-        Permissions.SHARED_GLOBAL,
-      ]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE, Permissions.CREATE, Permissions.SHARED_GLOBAL],
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).toHaveBeenCalled();
@@ -216,14 +316,16 @@ describe('Access Middleware', () => {
     test('should handle missing user gracefully', async () => {
       req.user = null;
 
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).not.toHaveBeenCalled();
-      expect(res.status).toHaveBeenCalledWith(500);
-      expect(res.json).toHaveBeenCalledWith({
-        message: expect.stringContaining('Server error:'),
-      });
+      expect(res.status).toHaveBeenCalledWith(403);
+      expect(res.json).toHaveBeenCalledWith({ message: 'Forbidden: Insufficient permissions' });
     });
 
     test('should handle role with no AGENTS permissions', async () => {
@@ -240,7 +342,11 @@ describe('Access Middleware', () => {
       });
       req.user.role = 'noaccess';
 
-      const middleware = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
+      const middleware = generateCheckAccess({
+        permissionType: PermissionTypes.AGENTS,
+        permissions: [Permissions.USE],
+        getRoleByName,
+      });
       await middleware(req, res, next);
 
       expect(next).not.toHaveBeenCalled();

api/server/routes/agents/index.js

@@ -10,7 +10,6 @@ const {
 const { isEnabled } = require('~/server/utils');
 const { v1 } = require('./v1');
 const chat = require('./chat');
-const marketplace = require('./marketplace');
 
 const { LIMIT_CONCURRENT_MESSAGES, LIMIT_MESSAGE_IP, LIMIT_MESSAGE_USER } = process.env ?? {};
 
@@ -39,6 +38,5 @@ chatRouter.use('/', chat);
 router.use('/chat', chatRouter);
 
 // Add marketplace routes
-router.use('/marketplace', marketplace);
 
 module.exports = router;

api/server/routes/agents/marketplace.js

@@ -1,46 +0,0 @@
-const express = require('express');
-const { requireJwtAuth, checkBan, generateCheckAccess } = require('~/server/middleware');
-const { PermissionTypes, Permissions } = require('librechat-data-provider');
-const marketplace = require('~/server/controllers/agents/marketplace');
-
-const router = express.Router();
-
-// Apply middleware for authentication and authorization
-router.use(requireJwtAuth);
-router.use(checkBan);
-
-// Check if user has permission to use agents
-const checkAgentAccess = generateCheckAccess(PermissionTypes.AGENTS, [Permissions.USE]);
-router.use(checkAgentAccess);
-
-/**
- * Get all agent categories with counts
- * @route GET /agents/marketplace/categories
- */
-router.get('/categories', marketplace.getAgentCategories);
-
-/**
- * Get promoted/top picks agents with pagination
- * @route GET /agents/marketplace/promoted
- */
-router.get('/promoted', marketplace.getPromotedAgents);
-
-/**
- * Get all agents with pagination (for "all" category)
- * @route GET /agents/marketplace/all
- */
-router.get('/all', marketplace.getAllAgents);
-
-/**
- * Search agents with filters
- * @route GET /agents/marketplace/search
- */
-router.get('/search', marketplace.searchAgents);
-
-/**
- * Get agents by category with pagination
- * @route GET /agents/marketplace/category/:category
- */
-router.get('/category/:category', marketplace.getAgentsByCategory);
-
-module.exports = router;

api/server/routes/agents/v1.js

@@ -45,6 +45,11 @@ router.use('/actions', actions);
  */
 router.use('/tools', tools);
 
+/**
+ * Get all agent categories with counts
+ * @route GET /agents/marketplace/categories
+ */
+router.get('/categories', v1.getAgentCategories);
 /**
  * Creates an agent.
  * @route POST /agents

api/server/services/AppService.interface.spec.js

@@ -1,6 +1,7 @@
 jest.mock('~/models', () => ({
   initializeRoles: jest.fn(),
   seedDefaultRoles: jest.fn(),
+  ensureDefaultCategories: jest.fn(),
 }));
 jest.mock('~/models/Role', () => ({
   updateAccessPermissions: jest.fn(),

api/server/services/AppService.js

@@ -16,7 +16,7 @@ const {
 const { azureAssistantsDefaults, assistantsConfigSetup } = require('./start/assistants');
 const { initializeAzureBlobService } = require('./Files/Azure/initialize');
 const { initializeFirebase } = require('./Files/Firebase/initialize');
-const { seedDefaultRoles, initializeRoles } = require('~/models');
+const { seedDefaultRoles, initializeRoles, ensureDefaultCategories } = require('~/models');
 const loadCustomConfig = require('./Config/loadCustomConfig');
 const handleRateLimits = require('./Config/handleRateLimits');
 const { loadDefaultInterface } = require('./start/interface');
@@ -37,6 +37,7 @@ const paths = require('~/config/paths');
 const AppService = async (app) => {
   await initializeRoles();
   await seedDefaultRoles();
+  await ensureDefaultCategories();
   /** @type {TCustomConfig} */
   const config = (await loadCustomConfig()) ?? {};
   const configDefaults = getConfigDefaults();

api/server/services/AppService.spec.js

@@ -29,6 +29,7 @@ jest.mock('./Files/Firebase/initialize', () => ({
 jest.mock('~/models', () => ({
   initializeRoles: jest.fn(),
   seedDefaultRoles: jest.fn(),
+  ensureDefaultCategories: jest.fn(),
 }));
 jest.mock('~/models/Role', () => ({
   updateAccessPermissions: jest.fn(),