Merge pull request #132 from huggingface/feat/skills-bouquet

skills bouquet!

Author: evalstate

packages/app/src/server/mcp-server.ts

@@ -989,7 +989,7 @@ export const createServerFactory = (_webServerInstance: WebServer, sharedApiClie
 					reason: toolSelection.reason,
 					enabledCount: toolSelection.enabledToolIds.length,
 					totalTools: Object.keys(toolInstances).length,
-					mixedBouquet: toolSelection.mixedBouquet,
+					mixedBouquet: toolSelection.mixedBouquet?.join(','),
 				},
 				'Tool selection strategy applied'
 			);

packages/app/src/server/utils/auth-utils.ts

@@ -3,15 +3,24 @@ import { logger } from '../utils/logger.js';
 /**
  * Extracts HF token, bouquet, mix, and gradio from headers and environment
  */
+function parseListParam(value: string | undefined): string[] | undefined {
+	if (!value) return undefined;
+	const parts = value
+		.split(',')
+		.map((part) => part.trim())
+		.filter(Boolean);
+	return parts.length > 0 ? parts : undefined;
+}
+
 export function extractAuthBouquetAndMix(headers: Record<string, string> | null): {
 	hfToken: string | undefined;
 	bouquet: string | undefined;
-	mix: string | undefined;
+	mix: string[] | undefined;
 	gradio: string | undefined;
 } {
 	let tokenFromHeader: string | undefined;
 	let bouquet: string | undefined;
-	let mix: string | undefined;
+	let mix: string[] | undefined;
 	let gradio: string | undefined;
 
 	if (headers) {
@@ -31,7 +40,7 @@ export function extractAuthBouquetAndMix(headers: Record<string, string> | null)
 
 		// Extract mix from custom header
 		if ('x-mcp-mix' in headers) {
-			mix = headers['x-mcp-mix'];
+			mix = parseListParam(headers['x-mcp-mix']);
 			logger.trace({ mix }, 'Mix parameter received');
 		}
 

packages/app/src/server/utils/query-params.ts

@@ -7,7 +7,7 @@ import type { Request } from 'express';
  */
 export function extractQueryParamsToHeaders(req: Request, headers: Record<string, string>): void {
 	const bouquet = req.query.bouquet as string | undefined;
-	const mix = req.query.mix as string | undefined;
+	const mix = Array.isArray(req.query.mix) ? req.query.mix.join(',') : (req.query.mix as string | undefined);
 	const gradio = req.query.gradio as string | undefined;
 	const forceauth = req.query.forceauth as string | undefined;
 	const login = req.query.login;

packages/app/src/server/utils/tool-selection-strategy.ts

@@ -26,7 +26,7 @@ export interface ToolSelectionResult {
 	enabledToolIds: string[];
 	reason: string;
 	baseSettings?: AppSettings;
-	mixedBouquet?: string;
+	mixedBouquet?: string[];
 	gradioSpaceTools?: SpaceTool[];
 }
 
@@ -128,6 +128,7 @@ export class ToolSelectionStrategy {
 	 */
 	async selectTools(context: ToolSelectionContext): Promise<ToolSelectionResult> {
 		const { bouquet, mix, gradio } = extractAuthBouquetAndMix(context.headers);
+		const mixList = mix ?? [];
 
 		// Parse gradio endpoints if provided (independent of bouquet selection)
 		// These endpoints will be registered in mcp-proxy.ts unless gradio="none"
@@ -151,30 +152,41 @@ export class ToolSelectionStrategy {
 		const baseSettings = await this.getUserSettings(context);
 
 		// 3. Apply mix if specified and we have base settings
-		if (mix && BOUQUETS[mix] && baseSettings) {
-			const mixedTools = [...baseSettings.builtInTools, ...BOUQUETS[mix].builtInTools];
-			const enabledToolIds = normalizeBuiltInTools(
-				this.applySearchEnablesFetch([...new Set(mixedTools)])
-			);
+		if (mixList.length > 0 && baseSettings) {
+			const validMixes = mixList.filter((mixName) => {
+				const isValid = Boolean(BOUQUETS[mixName]);
+				if (!isValid) {
+					logger.warn({ mixName }, 'Ignoring invalid mix bouquet name');
+				}
+				return isValid;
+			});
 
-			logger.debug(
-				{
-					mix,
-					baseToolCount: baseSettings.builtInTools.length,
-					mixToolCount: BOUQUETS[mix].builtInTools.length,
-					finalToolCount: enabledToolIds.length,
-				},
-				'Applying mix to user settings'
-			);
+				if (validMixes.length > 0) {
+					const mixedTools = validMixes.flatMap((mixName) => BOUQUETS[mixName]?.builtInTools ?? []);
+				const combinedTools = [...new Set([...baseSettings.builtInTools, ...mixedTools])];
+				const enabledToolIds = normalizeBuiltInTools(
+					this.applySearchEnablesFetch(combinedTools)
+				);
 
-			return {
-				mode: ToolSelectionMode.MIX,
-				enabledToolIds,
-				reason: `User settings + mix(${mix})${gradioSpaceTools.length > 0 ? ` + ${gradioSpaceTools.length} gradio endpoints` : ''}`,
-				baseSettings,
-				mixedBouquet: mix,
-				gradioSpaceTools: gradioSpaceTools.length > 0 ? gradioSpaceTools : undefined,
-			};
+				logger.debug(
+					{
+						mix: validMixes,
+						baseToolCount: baseSettings.builtInTools.length,
+						mixToolCount: mixedTools.length,
+						finalToolCount: enabledToolIds.length,
+					},
+					'Applying mix to user settings'
+				);
+
+				return {
+					mode: ToolSelectionMode.MIX,
+					enabledToolIds,
+					reason: `User settings + mix(${validMixes.join(',')})${gradioSpaceTools.length > 0 ? ` + ${gradioSpaceTools.length} gradio endpoints` : ''}`,
+					baseSettings,
+					mixedBouquet: validMixes,
+					gradioSpaceTools: gradioSpaceTools.length > 0 ? gradioSpaceTools : undefined,
+				};
+			}
 		}
 
 		// 4. Use base settings if available

packages/app/src/shared/bouquet-presets.ts

@@ -5,6 +5,9 @@ import {
 	USE_SPACE_TOOL_ID,
 	HF_JOBS_TOOL_ID,
 	DYNAMIC_SPACE_TOOL_ID,
+	MODEL_SEARCH_TOOL_ID,
+	DATASET_SEARCH_TOOL_ID,
+	DOCS_SEMANTIC_SEARCH_TOOL_ID,
 } from '@llmindset/hf-mcp';
 import type { AppSettings } from './settings.js';
 import { README_INCLUDE_FLAG, GRADIO_IMAGE_FILTER_FLAG } from './behavior-flags.js';
@@ -26,6 +29,17 @@ export const BOUQUETS: Record<string, AppSettings> = {
 		builtInTools: [...TOOL_ID_GROUPS.docs],
 		spaceTools: [],
 	},
+	skills: {
+		builtInTools: [
+			HUB_INSPECT_TOOL_ID,
+			README_INCLUDE_FLAG,
+			MODEL_SEARCH_TOOL_ID,
+			DATASET_SEARCH_TOOL_ID,
+			DOCS_SEMANTIC_SEARCH_TOOL_ID,
+			HF_JOBS_TOOL_ID,
+		],
+		spaceTools: [],
+	},
 	all: {
 		builtInTools: [...ALL_BUILTIN_TOOL_IDS],
 		spaceTools: [],

packages/app/test/server/utils/query-params.test.ts

@@ -27,6 +27,17 @@ describe('extractQueryParamsToHeaders', () => {
 		expect(headers['x-mcp-bouquet']).toBeUndefined();
 	});
 
+	it('should join multiple mix query parameters', () => {
+		const req = {
+			query: { mix: ['hf_api', 'jobs'] },
+		} as unknown as Request;
+
+		const headers: Record<string, string> = {};
+		extractQueryParamsToHeaders(req, headers);
+
+		expect(headers['x-mcp-mix']).toBe('hf_api,jobs');
+	});
+
 	it('should extract both bouquet and mix query parameters', () => {
 		const req = {
 			query: { bouquet: 'search', mix: 'hf_api' },

packages/app/test/server/utils/tool-selection-strategy.test.ts

@@ -22,7 +22,7 @@ describe('extractBouquetAndMix', () => {
 		const result = extractAuthBouquetAndMix(headers);
 
 		expect(result.bouquet).toBeUndefined();
-		expect(result.mix).toBe('hf_api');
+		expect(result.mix).toEqual(['hf_api']);
 	});
 
 	it('should extract both bouquet and mix from headers', () => {
@@ -33,7 +33,7 @@ describe('extractBouquetAndMix', () => {
 		const result = extractAuthBouquetAndMix(headers);
 
 		expect(result.bouquet).toBe('search');
-		expect(result.mix).toBe('hf_api');
+		expect(result.mix).toEqual(['hf_api']);
 	});
 
 	it('should handle null headers', () => {
@@ -49,6 +49,13 @@ describe('extractBouquetAndMix', () => {
 		expect(result.bouquet).toBeUndefined();
 		expect(result.mix).toBeUndefined();
 	});
+
+	it('should parse comma-separated mix list', () => {
+		const headers = { 'x-mcp-mix': 'hf_api, jobs ,hub_repo_details_readme' };
+		const result = extractAuthBouquetAndMix(headers);
+
+		expect(result.mix).toEqual(['hf_api', 'jobs', 'hub_repo_details_readme']);
+	});
 });
 
 describe('BOUQUETS configuration', () => {
@@ -224,7 +231,7 @@ describe('ToolSelectionStrategy', () => {
 			expect(result.mode).toBe(ToolSelectionMode.MIX);
 			expect(result.reason).toBe('User settings + mix(hf_api)');
 			expect(result.baseSettings).toEqual(userSettings);
-			expect(result.mixedBouquet).toBe('hf_api');
+			expect(result.mixedBouquet).toEqual(['hf_api']);
 
 			// Should contain user tools + hf_api tools (deduplicated)
 			const expectedTools = [...new Set([...userSettings.builtInTools, ...TOOL_ID_GROUPS.hf_api])];
@@ -274,6 +281,30 @@ describe('ToolSelectionStrategy', () => {
 			expect(result.enabledToolIds.length).toBe(uniqueTools.length);
 		});
 
+		it('should mix multiple bouquets when comma separated', async () => {
+			const userSettings: AppSettings = {
+				builtInTools: ['hf_whoami'],
+				spaceTools: [],
+			};
+
+			const context: ToolSelectionContext = {
+				headers: { 'x-mcp-mix': 'hf_api,search' },
+				userSettings,
+				hfToken: 'test-token',
+			};
+
+			const result = await strategy.selectTools(context);
+
+			expect(result.mode).toBe(ToolSelectionMode.MIX);
+			expect(result.reason).toBe('User settings + mix(hf_api,search)');
+			expect(result.mixedBouquet).toEqual(['hf_api', 'search']);
+
+			const expectedTools = normalizeBuiltInTools([
+				...new Set([...userSettings.builtInTools, ...TOOL_ID_GROUPS.hf_api, ...TOOL_ID_GROUPS.search]),
+			]);
+			expect(result.enabledToolIds).toEqual(expectedTools);
+		});
+
 		it('should ignore mix when no user settings available', async () => {
 			const context: ToolSelectionContext = {
 				headers: { 'x-mcp-mix': 'hf_api' },
@@ -431,7 +462,7 @@ describe('ToolSelectionStrategy', () => {
 
 			expect(result.mode).toBe(ToolSelectionMode.MIX);
 			expect(result.enabledToolIds).toEqual(TOOL_ID_GROUPS.search);
-			expect(result.mixedBouquet).toBe('search');
+			expect(result.mixedBouquet).toEqual(['search']);
 		});
 
 		it('should handle all possible tool types in mix', async () => {
@@ -451,7 +482,7 @@ describe('ToolSelectionStrategy', () => {
 				const result = await strategy.selectTools(context);
 
 				expect(result.mode).toBe(ToolSelectionMode.MIX);
-				expect(result.mixedBouquet).toBe(bouquetName);
+				expect(result.mixedBouquet).toEqual([bouquetName]);
 
 				const expectedTools = [...new Set([...userSettings.builtInTools, ...bouquetConfig.builtInTools])];
 				expect(result.enabledToolIds).toEqual(normalizeBuiltInTools(expectedTools));
@@ -486,7 +517,7 @@ describe('ToolSelectionStrategy', () => {
 			const result = await strategy.selectTools(context);
 
 			expect(result.mode).toBe(ToolSelectionMode.MIX);
-			expect(result.mixedBouquet).toBe('all');
+			expect(result.mixedBouquet).toEqual(['all']);
 			expect(result.reason).toBe('User settings + mix(all)');
 
 			// Should get user's minimal tools + ALL built-in tools (deduplicated)