🏪 feat: Agent Marketplace

bugfix: Enhance Agent and AgentCategory schemas with new fields for category, support contact, and promotion status

refactored and moved agent category methods and schema to data-schema package

🔧 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

🔧 fix: Fixed agent actions access

feat: Add role-level permissions for agent sharing people picker

  - Add PEOPLE_PICKER permission type with VIEW_USERS and VIEW_GROUPS permissions
  - Create custom middleware for query-aware permission validation
  - Implement permission-based type filtering in PeoplePicker component
  - Hide people picker UI when user lacks permissions, show only public toggle
  - Support granular access: users-only, groups-only, or mixed search modes

refactor: Replace marketplace interface config with permission-based system

  - Add MARKETPLACE permission type to handle marketplace access control
  - Update interface configuration to use role-based marketplace settings (admin/user)
  - Replace direct marketplace boolean config with permission-based checks
  - Modify frontend components to use marketplace permissions instead of interface config
  - Update agent query hooks to use marketplace permissions for determining permission levels
  - Add marketplace configuration structure similar to peoplePicker in YAML config
  - Backend now sets MARKETPLACE permissions based on interface configuration
  - When marketplace enabled: users get agents with EDIT permissions in dropdown lists  (builder mode)
  - When marketplace disabled: users get agents with VIEW permissions  in dropdown lists (browse mode)

🔧 fix: Redirect to New Chat if No Marketplace Access and Required Agent Name Placeholder (#8213)

* Fix: Fix the redirect to new chat page if access to marketplace is denied

* Fixed the required agent name placeholder

---------

Co-authored-by: Atef Bellaaj <slalom.bellaaj@external.daimlertruck.com>

chore: fix tests, remove unnecessary imports

refactor: Implement permission checks for file access via agents

- Updated `hasAccessToFilesViaAgent` to utilize permission checks for VIEW and EDIT access.
- Replaced project-based access validation with permission-based checks.
- Enhanced tests to cover new permission logic and ensure proper access control for files associated with agents.
- Cleaned up imports and initialized models in test files for consistency.

refactor: Enhance test setup and cleanup for file access control

- Introduced modelsToCleanup array to track models added during tests for proper cleanup.
- Updated afterAll hooks in test files to ensure all collections are cleared and only added models are deleted.
- Improved consistency in model initialization across test files.
- Added comments for clarity on cleanup processes and test data management.

chore: Update Jest configuration and test setup for improved timeout handling

- Added a global test timeout of 30 seconds in jest.config.js.
- Configured jest.setTimeout in jestSetup.js to allow individual test overrides if needed.
- Enhanced test reliability by ensuring consistent timeout settings across all tests.

refactor: Implement file access filtering based on agent permissions

- Introduced `filterFilesByAgentAccess` function to filter files based on user access through agents.
- Updated `getFiles` and `primeFiles` functions to utilize the new filtering logic.
- Moved `hasAccessToFilesViaAgent` function from the File model to permission services, adjusting imports accordingly
- Enhanced tests to ensure proper access control and filtering behavior for files associated with agents.

fix: make support_contact field a nested object rather than a sub-document

refactor: Update support_contact field initialization in agent model

- Removed handling for empty support_contact object in createAgent function.
- Changed default value of support_contact in agent schema to undefined.

test: Add comprehensive tests for support_contact field handling and versioning

refactor: remove unused avatar upload mutation field and add informational toast for success

chore: add missing SidePanelProvider for AgentMarketplace and organize imports

fix: resolve agent selection race condition in marketplace HandleStartChat
- Set agent in localStorage before newConversation to prevent useSelectorEffects from auto-selecting previous agent

fix: resolve agent dropdown showing raw ID instead of agent info from URL

  - Add proactive agent fetching when agent_id is present in URL parameters
  - Inject fetched agent into agents cache so dropdowns display proper name/avatar
  - Use useAgentsMap dependency to ensure proper cache initialization timing
  - Prevents raw agent IDs from showing in UI when visiting shared agent links

Fix: Agents endpoint renamed to "My Agent" for less confusion with the Marketplace agents.

chore: fix ESLint issues and Test Mocks

ci: update permissions structure in loadDefaultInterface tests

- Refactored permissions for MEMORY and added new permissions for MARKETPLACE and PEOPLE_PICKER.
- Ensured consistent structure for permissions across different types.

feat:  support_contact validation to allow empty email strings
This commit is contained in:
“Praneeth 2025-06-11 22:55:07 +05:30 committed by Danny Avila
parent 66bd419baa
commit 949682ef0f
No known key found for this signature in database
GPG key ID: BF31EEB2C5CA0956
95 changed files with 3770 additions and 2728 deletions

View file

@ -30,6 +30,14 @@ export const agentToolResourcesSchema = z
})
.optional();
/** Support contact schema for agent */
export const agentSupportContactSchema = z
.object({
name: z.string().optional(),
email: z.union([z.literal(''), z.string().email()]).optional(),
})
.optional();
/** Base agent schema with all common fields */
export const agentBaseSchema = z.object({
name: z.string().nullable().optional(),
@ -45,6 +53,8 @@ export const agentBaseSchema = z.object({
recursion_limit: z.number().optional(),
conversation_starters: z.array(z.string()).optional(),
tool_resources: agentToolResourcesSchema,
support_contact: agentSupportContactSchema,
category: z.string().optional(),
});
/** Create schema extends base with required fields for creation */

View file

@ -125,7 +125,7 @@ export const generateCheckAccess = ({
}
logger.warn(
`[${permissionType}] Forbidden: "${req.originalUrl}" - Insufficient permissions for User ${req.user?.id}: ${permissions.join(', ')}`,
`[${permissionType}] Forbidden: "${req.originalUrl}" - Insufficient permissions for User ${(req.user as IUser)?.id}: ${permissions.join(', ')}`,
);
return res.status(403).json({ message: 'Forbidden: Insufficient permissions' });
} catch (error) {

View file

@ -498,7 +498,7 @@ const mcpServersSchema = z.object({
export type TMcpServersConfig = z.infer<typeof mcpServersSchema>;
export const intefaceSchema = z
export const interfaceSchema = z
.object({
privacyPolicy: z
.object({
@ -523,6 +523,36 @@ export const intefaceSchema = z
temporaryChatRetention: z.number().min(1).max(8760).optional(),
runCode: z.boolean().optional(),
webSearch: z.boolean().optional(),
peoplePicker: z
.object({
admin: z
.object({
users: z.boolean().optional(),
groups: z.boolean().optional(),
})
.optional(),
user: z
.object({
users: z.boolean().optional(),
groups: z.boolean().optional(),
})
.optional(),
})
.optional(),
marketplace: z
.object({
admin: z
.object({
use: z.boolean().optional(),
})
.optional(),
user: z
.object({
use: z.boolean().optional(),
})
.optional(),
})
.optional(),
fileSearch: z.boolean().optional(),
fileCitations: z.boolean().optional(),
})
@ -540,11 +570,29 @@ export const intefaceSchema = z
temporaryChat: true,
runCode: true,
webSearch: true,
peoplePicker: {
admin: {
users: true,
groups: true,
},
user: {
users: false,
groups: false,
},
},
marketplace: {
admin: {
use: false,
},
user: {
use: false,
},
},
fileSearch: true,
fileCitations: true,
});
export type TInterfaceConfig = z.infer<typeof intefaceSchema>;
export type TInterfaceConfig = z.infer<typeof interfaceSchema>;
export type TBalanceConfig = z.infer<typeof balanceSchema>;
export const turnstileOptionsSchema = z
@ -771,7 +819,7 @@ export const configSchema = z.object({
includedTools: z.array(z.string()).optional(),
filteredTools: z.array(z.string()).optional(),
mcpServers: MCPServersSchema.optional(),
interface: intefaceSchema,
interface: interfaceSchema,
turnstile: turnstileSchema.optional(),
fileStrategy: fileSourceSchema.default(FileSources.local),
actions: z
@ -867,7 +915,7 @@ export const defaultEndpoints: EModelEndpoint[] = [
export const alternateName = {
[EModelEndpoint.openAI]: 'OpenAI',
[EModelEndpoint.assistants]: 'Assistants',
[EModelEndpoint.agents]: 'Agents',
[EModelEndpoint.agents]: 'My Agents',
[EModelEndpoint.azureAssistants]: 'Azure Assistants',
[EModelEndpoint.azureOpenAI]: 'Azure OpenAI',
[EModelEndpoint.chatGPTBrowser]: 'ChatGPT',

View file

@ -477,69 +477,23 @@ export const revertAgentVersion = ({
* Get agent categories with counts for marketplace tabs
*/
export const getAgentCategories = (): Promise<t.TMarketplaceCategory[]> => {
return request.get(endpoints.agents({ path: 'marketplace/categories' }));
return request.get(endpoints.agents({ path: 'categories' }));
};
/**
* Get promoted/top picks agents with pagination
* Unified marketplace agents endpoint with query string controls
*/
export const getPromotedAgents = (params: {
page?: number;
limit?: number;
showAll?: string; // Add showAll parameter to get all shared agents instead of just promoted
}): Promise<a.AgentListResponse> => {
return request.get(
endpoints.agents({
path: 'marketplace/promoted',
options: params,
}),
);
};
/**
* Get all agents with pagination (for "all" category)
*/
export const getAllAgents = (params: {
page?: number;
limit?: number;
}): Promise<a.AgentListResponse> => {
return request.get(
endpoints.agents({
path: 'marketplace/all',
options: params,
}),
);
};
/**
* Get agents by category with pagination
*/
export const getAgentsByCategory = (params: {
category: string;
page?: number;
limit?: number;
}): Promise<a.AgentListResponse> => {
const { category, ...options } = params;
return request.get(
endpoints.agents({
path: `marketplace/category/${category}`,
options,
}),
);
};
/**
* Search agents in marketplace
*/
export const searchAgents = (params: {
q: string;
export const getMarketplaceAgents = (params: {
requiredPermission: number;
category?: string;
page?: number;
search?: string;
limit?: number;
cursor?: string;
promoted?: 0 | 1;
}): Promise<a.AgentListResponse> => {
return request.get(
endpoints.agents({
path: 'marketplace/search',
// path: 'marketplace',
options: params,
}),
);

View file

@ -39,6 +39,8 @@ import * as dataService from './data-service';
export * from './utils';
export * from './actions';
export { default as createPayload } from './createPayload';
// /* react query hooks */
// export * from './react-query/react-query-service';
/* feedback */
export * from './feedback';
export * from './parameterSettings';

View file

@ -43,6 +43,8 @@ export enum QueryKeys {
promptGroup = 'promptGroup',
categories = 'categories',
randomPrompts = 'randomPrompts',
agentCategories = 'agentCategories',
marketplaceAgents = 'marketplaceAgents',
roles = 'roles',
conversationTags = 'conversationTags',
health = 'health',

View file

@ -36,6 +36,14 @@ export enum PermissionTypes {
* Type for using the "Web Search" feature
*/
WEB_SEARCH = 'WEB_SEARCH',
/**
* Type for People Picker Permissions
*/
PEOPLE_PICKER = 'PEOPLE_PICKER',
/**
* Type for Marketplace Permissions
*/
MARKETPLACE = 'MARKETPLACE',
/**
* Type for using the "File Search" feature
*/
@ -59,6 +67,8 @@ export enum Permissions {
SHARE = 'SHARE',
/** Can disable if desired */
OPT_OUT = 'OPT_OUT',
VIEW_USERS = 'VIEW_USERS',
VIEW_GROUPS = 'VIEW_GROUPS',
}
export const promptPermissionsSchema = z.object({
@ -111,6 +121,17 @@ export const webSearchPermissionsSchema = z.object({
});
export type TWebSearchPermissions = z.infer<typeof webSearchPermissionsSchema>;
export const peoplePickerPermissionsSchema = z.object({
[Permissions.VIEW_USERS]: z.boolean().default(true),
[Permissions.VIEW_GROUPS]: z.boolean().default(true),
});
export type TPeoplePickerPermissions = z.infer<typeof peoplePickerPermissionsSchema>;
export const marketplacePermissionsSchema = z.object({
[Permissions.USE]: z.boolean().default(false),
});
export type TMarketplacePermissions = z.infer<typeof marketplacePermissionsSchema>;
export const fileSearchPermissionsSchema = z.object({
[Permissions.USE]: z.boolean().default(true),
});
@ -131,6 +152,8 @@ export const permissionsSchema = z.object({
[PermissionTypes.TEMPORARY_CHAT]: temporaryChatPermissionsSchema,
[PermissionTypes.RUN_CODE]: runCodePermissionsSchema,
[PermissionTypes.WEB_SEARCH]: webSearchPermissionsSchema,
[PermissionTypes.PEOPLE_PICKER]: peoplePickerPermissionsSchema,
[PermissionTypes.MARKETPLACE]: marketplacePermissionsSchema,
[PermissionTypes.FILE_SEARCH]: fileSearchPermissionsSchema,
[PermissionTypes.FILE_CITATIONS]: fileCitationsPermissionsSchema,
});

View file

@ -12,6 +12,7 @@ import {
fileSearchPermissionsSchema,
multiConvoPermissionsSchema,
temporaryChatPermissionsSchema,
peoplePickerPermissionsSchema,
fileCitationsPermissionsSchema,
} from './permissions';
@ -76,6 +77,13 @@ const defaultRolesSchema = z.object({
[PermissionTypes.WEB_SEARCH]: webSearchPermissionsSchema.extend({
[Permissions.USE]: z.boolean().default(true),
}),
[PermissionTypes.PEOPLE_PICKER]: peoplePickerPermissionsSchema.extend({
[Permissions.VIEW_USERS]: z.boolean().default(true),
[Permissions.VIEW_GROUPS]: z.boolean().default(true),
}),
[PermissionTypes.MARKETPLACE]: z.object({
[Permissions.USE]: z.boolean().default(false),
}),
[PermissionTypes.FILE_SEARCH]: fileSearchPermissionsSchema.extend({
[Permissions.USE]: z.boolean().default(true),
}),
@ -126,6 +134,13 @@ export const roleDefaults = defaultRolesSchema.parse({
[PermissionTypes.WEB_SEARCH]: {
[Permissions.USE]: true,
},
[PermissionTypes.PEOPLE_PICKER]: {
[Permissions.VIEW_USERS]: true,
[Permissions.VIEW_GROUPS]: true,
},
[PermissionTypes.MARKETPLACE]: {
[Permissions.USE]: true,
},
[PermissionTypes.FILE_SEARCH]: {
[Permissions.USE]: true,
},
@ -145,6 +160,13 @@ export const roleDefaults = defaultRolesSchema.parse({
[PermissionTypes.TEMPORARY_CHAT]: {},
[PermissionTypes.RUN_CODE]: {},
[PermissionTypes.WEB_SEARCH]: {},
[PermissionTypes.PEOPLE_PICKER]: {
[Permissions.VIEW_USERS]: false,
[Permissions.VIEW_GROUPS]: false,
},
[PermissionTypes.MARKETPLACE]: {
[Permissions.USE]: false,
},
[PermissionTypes.FILE_SEARCH]: {},
[PermissionTypes.FILE_CITATIONS]: {},
},

View file

@ -196,6 +196,10 @@ export interface AgentFileResource extends AgentBaseResource {
*/
vector_store_ids?: Array<string>;
}
export type SupportContact = {
name?: string;
email?: string;
};
export type Agent = {
_id?: string;
@ -228,6 +232,8 @@ export type Agent = {
recursion_limit?: number;
isPublic?: boolean;
version?: number;
category?: string;
support_contact?: SupportContact;
};
export type TAgentsMap = Record<string, Agent | undefined>;
@ -244,7 +250,13 @@ export type AgentCreateParams = {
model_parameters: AgentModelParameters;
} & Pick<
Agent,
'agent_ids' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit'
| 'agent_ids'
| 'end_after_tools'
| 'hide_sequential_outputs'
| 'artifacts'
| 'recursion_limit'
| 'category'
| 'support_contact'
>;
export type AgentUpdateParams = {
@ -263,15 +275,22 @@ export type AgentUpdateParams = {
isCollaborative?: boolean;
} & Pick<
Agent,
'agent_ids' | 'end_after_tools' | 'hide_sequential_outputs' | 'artifacts' | 'recursion_limit'
| 'agent_ids'
| 'end_after_tools'
| 'hide_sequential_outputs'
| 'artifacts'
| 'recursion_limit'
| 'category'
| 'support_contact'
>;
export type AgentListParams = {
limit?: number;
before?: string | null;
after?: string | null;
order?: 'asc' | 'desc';
provider?: AgentProvider;
requiredPermission: number;
category?: string;
search?: string;
cursor?: string;
promoted?: 0 | 1;
};
export type AgentListResponse = {
@ -280,6 +299,7 @@ export type AgentListResponse = {
first_id: string;
last_id: string;
has_more: boolean;
after?: string;
};
export type AgentFile = {

View file

@ -109,7 +109,6 @@ export type DeleteActionOptions = MutationOptions<void, DeleteActionVariables>;
export type AgentAvatarVariables = {
agent_id: string;
formData: FormData;
postCreation?: boolean;
};
export type UpdateAgentActionVariables = {

View file

@ -271,22 +271,7 @@ describe('AclEntry Model Tests', () => {
const effective = await methods.getEffectivePermissions(principalsList, 'agent', resourceId);
/** Combined permissions should be VIEW | EDIT */
expect(effective.effectiveBits).toBe(PermissionBits.VIEW | PermissionBits.EDIT);
/** Should have 2 sources */
expect(effective.sources).toHaveLength(2);
/** Check sources */
const userSource = effective.sources.find((s) => s.from === 'user');
const groupSource = effective.sources.find((s) => s.from === 'group');
expect(userSource).toBeDefined();
expect(userSource?.permBits).toBe(PermissionBits.VIEW);
expect(userSource?.direct).toBe(true);
expect(groupSource).toBeDefined();
expect(groupSource?.permBits).toBe(PermissionBits.EDIT);
expect(groupSource?.direct).toBe(true);
expect(effective).toBe(PermissionBits.VIEW | PermissionBits.EDIT);
});
});
@ -489,16 +474,15 @@ describe('AclEntry Model Tests', () => {
inheritedFrom: projectId,
});
/** Get effective permissions including sources */
/** Get effective permissions */
const effective = await methods.getEffectivePermissions(
[{ principalType: 'user', principalId: userId }],
'agent',
childResourceId,
);
expect(effective.sources).toHaveLength(1);
expect(effective.sources[0].inheritedFrom?.toString()).toBe(projectId.toString());
expect(effective.sources[0].direct).toBe(false);
/** Should have VIEW permission from inherited entry */
expect(effective).toBe(PermissionBits.VIEW);
});
});
});

View file

@ -0,0 +1,222 @@
import type { Model, Types, DeleteResult } from 'mongoose';
import type { IAgentCategory, AgentCategory } from '../types/agentCategory';
export function createAgentCategoryMethods(mongoose: typeof import('mongoose')) {
/**
* Get all active categories sorted by order
* @returns Array of active categories
*/
async function getActiveCategories(): Promise<IAgentCategory[]> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.find({ isActive: true }).sort({ order: 1, label: 1 }).lean();
}
/**
* Get categories with agent counts
* @returns Categories with agent counts
*/
async function getCategoriesWithCounts(): Promise<(IAgentCategory & { agentCount: number })[]> {
const Agent = mongoose.models.Agent;
const categoryCounts = await Agent.aggregate([
{ $match: { category: { $exists: true, $ne: null } } },
{ $group: { _id: '$category', count: { $sum: 1 } } },
]);
const countMap = new Map(categoryCounts.map((c) => [c._id, c.count]));
const categories = await getActiveCategories();
return categories.map((category) => ({
...category,
agentCount: countMap.get(category.value) || (0 as number),
})) as (IAgentCategory & { agentCount: number })[];
}
/**
* Get valid category values for Agent model validation
* @returns Array of valid category values
*/
async function getValidCategoryValues(): Promise<string[]> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.find({ isActive: true }).distinct('value').lean();
}
/**
* Seed initial categories from existing constants
* @param categories - Array of category data to seed
* @returns Bulk write result
*/
async function seedCategories(
categories: Array<{
value: string;
label?: string;
description?: string;
order?: number;
}>,
): Promise<any> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
const operations = categories.map((category, index) => ({
updateOne: {
filter: { value: category.value },
update: {
$setOnInsert: {
value: category.value,
label: category.label || category.value,
description: category.description || '',
order: category.order || index,
isActive: true,
},
},
upsert: true,
},
}));
return await AgentCategory.bulkWrite(operations);
}
/**
* Find a category by value
* @param value - The category value to search for
* @returns The category document or null
*/
async function findCategoryByValue(value: string): Promise<IAgentCategory | null> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.findOne({ value }).lean();
}
/**
* Create a new category
* @param categoryData - The category data to create
* @returns The created category
*/
async function createCategory(categoryData: Partial<IAgentCategory>): Promise<IAgentCategory> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
const category = await AgentCategory.create(categoryData);
return category.toObject() as IAgentCategory;
}
/**
* Update a category by value
* @param value - The category value to update
* @param updateData - The data to update
* @returns The updated category or null
*/
async function updateCategory(
value: string,
updateData: Partial<IAgentCategory>,
): Promise<IAgentCategory | null> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.findOneAndUpdate(
{ value },
{ $set: updateData },
{ new: true, runValidators: true },
).lean();
}
/**
* Delete a category by value
* @param value - The category value to delete
* @returns Whether the deletion was successful
*/
async function deleteCategory(value: string): Promise<boolean> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
const result = await AgentCategory.deleteOne({ value });
return result.deletedCount > 0;
}
/**
* Find a category by ID
* @param id - The category ID to search for
* @returns The category document or null
*/
async function findCategoryById(id: string | Types.ObjectId): Promise<IAgentCategory | null> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.findById(id).lean();
}
/**
* Get all categories (active and inactive)
* @returns Array of all categories
*/
async function getAllCategories(): Promise<IAgentCategory[]> {
const AgentCategory = mongoose.models.AgentCategory as Model<IAgentCategory>;
return await AgentCategory.find({}).sort({ order: 1, label: 1 }).lean();
}
/**
* Ensure default categories exist, seed them if none are present
* @returns Promise<boolean> - true if categories were seeded, false if they already existed
*/
async function ensureDefaultCategories(): Promise<boolean> {
const existingCategories = await getAllCategories();
if (existingCategories.length > 0) {
return false; // Categories already exist
}
const defaultCategories = [
{
value: 'general',
label: 'General',
description: 'General purpose agents for common tasks and inquiries',
order: 0,
},
{
value: 'hr',
label: 'Human Resources',
description: 'Agents specialized in HR processes, policies, and employee support',
order: 1,
},
{
value: 'rd',
label: 'Research & Development',
description: 'Agents focused on R&D processes, innovation, and technical research',
order: 2,
},
{
value: 'finance',
label: 'Finance',
description: 'Agents specialized in financial analysis, budgeting, and accounting',
order: 3,
},
{
value: 'it',
label: 'IT',
description: 'Agents for IT support, technical troubleshooting, and system administration',
order: 4,
},
{
value: 'sales',
label: 'Sales',
description: 'Agents focused on sales processes, customer relations.',
order: 5,
},
{
value: 'aftersales',
label: 'After Sales',
description: 'Agents specialized in post-sale support, maintenance, and customer service',
order: 6,
},
];
await seedCategories(defaultCategories);
return true; // Categories were seeded
}
return {
getActiveCategories,
getCategoriesWithCounts,
getValidCategoryValues,
seedCategories,
findCategoryByValue,
createCategory,
updateCategory,
deleteCategory,
findCategoryById,
getAllCategories,
ensureDefaultCategories,
};
}
export type AgentCategoryMethods = ReturnType<typeof createAgentCategoryMethods>;

View file

@ -4,6 +4,8 @@ import { createTokenMethods, type TokenMethods } from './token';
import { createRoleMethods, type RoleMethods } from './role';
/* Memories */
import { createMemoryMethods, type MemoryMethods } from './memory';
/* Agent Categories */
import { createAgentCategoryMethods, type AgentCategoryMethods } from './agentCategory';
/* Permissions */
import { createAccessRoleMethods, type AccessRoleMethods } from './accessRole';
import { createUserGroupMethods, type UserGroupMethods } from './userGroup';
@ -22,6 +24,7 @@ export function createMethods(mongoose: typeof import('mongoose')) {
...createTokenMethods(mongoose),
...createRoleMethods(mongoose),
...createMemoryMethods(mongoose),
...createAgentCategoryMethods(mongoose),
...createAccessRoleMethods(mongoose),
...createUserGroupMethods(mongoose),
...createAclEntryMethods(mongoose),
@ -37,6 +40,7 @@ export type AllMethods = UserMethods &
TokenMethods &
RoleMethods &
MemoryMethods &
AgentCategoryMethods &
AccessRoleMethods &
UserGroupMethods &
AclEntryMethods &

View file

@ -0,0 +1,9 @@
import agentCategorySchema from '~/schema/agentCategory';
import type * as t from '~/types';
/**
* Creates or returns the AgentCategory model using the provided mongoose instance and schema
*/
export function createAgentCategoryModel(mongoose: typeof import('mongoose')) {
return mongoose.models.AgentCategory || mongoose.model<t.IAgentCategory>('AgentCategory', agentCategorySchema);
}

View file

@ -5,6 +5,7 @@ import { createBalanceModel } from './balance';
import { createConversationModel } from './convo';
import { createMessageModel } from './message';
import { createAgentModel } from './agent';
import { createAgentCategoryModel } from './agentCategory';
import { createRoleModel } from './role';
import { createActionModel } from './action';
import { createAssistantModel } from './assistant';
@ -37,6 +38,7 @@ export function createModels(mongoose: typeof import('mongoose')) {
Conversation: createConversationModel(mongoose),
Message: createMessageModel(mongoose),
Agent: createAgentModel(mongoose),
AgentCategory: createAgentCategoryModel(mongoose),
Role: createRoleModel(mongoose),
Action: createActionModel(mongoose),
Assistant: createAssistantModel(mongoose),

View file

@ -92,6 +92,21 @@ const agentSchema = new Schema<IAgent>(
type: [Schema.Types.Mixed],
default: [],
},
category: {
type: String,
trim: true,
index: true,
default: 'general',
},
support_contact: {
type: Schema.Types.Mixed,
default: undefined,
},
is_promoted: {
type: Boolean,
default: false,
index: true,
},
},
{
timestamps: true,

View file

@ -0,0 +1,42 @@
import { Schema, Document } from 'mongoose';
import type { IAgentCategory } from '~/types';
const agentCategorySchema = new Schema<IAgentCategory>(
{
value: {
type: String,
required: true,
unique: true,
trim: true,
lowercase: true,
index: true,
},
label: {
type: String,
required: true,
trim: true,
},
description: {
type: String,
trim: true,
default: '',
},
order: {
type: Number,
default: 0,
index: true,
},
isActive: {
type: Boolean,
default: true,
index: true,
},
},
{
timestamps: true,
},
);
agentCategorySchema.index({ isActive: 1, order: 1 });
export default agentCategorySchema;

View file

@ -1,5 +1,6 @@
export { default as actionSchema } from './action';
export { default as agentSchema } from './agent';
export { default as agentCategorySchema } from './agentCategory';
export { default as assistantSchema } from './assistant';
export { default as balanceSchema } from './balance';
export { default as bannerSchema } from './banner';

View file

@ -39,6 +39,13 @@ const rolePermissionsSchema = new Schema(
[PermissionTypes.WEB_SEARCH]: {
[Permissions.USE]: { type: Boolean, default: true },
},
[PermissionTypes.PEOPLE_PICKER]: {
[Permissions.VIEW_USERS]: { type: Boolean, default: false },
[Permissions.VIEW_GROUPS]: { type: Boolean, default: false },
},
[PermissionTypes.MARKETPLACE]: {
[Permissions.USE]: { type: Boolean, default: false },
},
[PermissionTypes.FILE_SEARCH]: {
[Permissions.USE]: { type: Boolean, default: true },
},
@ -75,6 +82,11 @@ const roleSchema: Schema<IRole> = new Schema({
[PermissionTypes.TEMPORARY_CHAT]: { [Permissions.USE]: true },
[PermissionTypes.RUN_CODE]: { [Permissions.USE]: true },
[PermissionTypes.WEB_SEARCH]: { [Permissions.USE]: true },
[PermissionTypes.PEOPLE_PICKER]: {
[Permissions.VIEW_USERS]: false,
[Permissions.VIEW_GROUPS]: false,
},
[PermissionTypes.MARKETPLACE]: { [Permissions.USE]: false },
[PermissionTypes.FILE_SEARCH]: { [Permissions.USE]: true },
[PermissionTypes.FILE_CITATIONS]: { [Permissions.USE]: true },
}),

View file

@ -36,4 +36,5 @@ export interface IAgent extends Omit<Document, 'model'> {
versions?: Omit<IAgent, 'versions'>[];
category: string;
support_contact?: ISupportContact;
is_promoted?: boolean;
}

View file

@ -0,0 +1,19 @@
import type { Document, Types } from 'mongoose';
export type AgentCategory = {
/** Unique identifier for the category (e.g., 'general', 'hr', 'finance') */
value: string;
/** Display label for the category */
label: string;
/** Description of the category */
description?: string;
/** Display order for sorting categories */
order: number;
/** Whether the category is active and should be displayed */
isActive: boolean;
};
export type IAgentCategory = AgentCategory &
Document & {
_id: Types.ObjectId;
};

View file

@ -9,6 +9,7 @@ export * from './balance';
export * from './banner';
export * from './message';
export * from './agent';
export * from './agentCategory';
export * from './role';
export * from './action';
export * from './assistant';

View file

@ -35,6 +35,13 @@ export interface IRole extends Document {
[PermissionTypes.WEB_SEARCH]?: {
[Permissions.USE]?: boolean;
};
[PermissionTypes.PEOPLE_PICKER]?: {
[Permissions.VIEW_USERS]?: boolean;
[Permissions.VIEW_GROUPS]?: boolean;
};
[PermissionTypes.MARKETPLACE]?: {
[Permissions.USE]?: boolean;
};
[PermissionTypes.FILE_SEARCH]?: {
[Permissions.USE]?: boolean;
};