@llmindset/hf-mcp-server 0.2.45 → 0.2.47

package/dist/server/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/mcp-server.ts"],"names":[],"mappings":"AAgEA,OAAO,KAAK,EAAE,aAAa,EAAuB,MAAM,+BAA+B,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAS9E,eAAO,MAAM,gBAAgB,EAAE,WAG9B,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,WAGlC,CAAC;AAQF,eAAO,MAAM,mBAAmB,GAAI,oBAAoB,SAAS,EAAE,iBAAiB,YAAY,KAAG,aAgyBlG,CAAC"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/server/mcp-server.ts"],"names":[],"mappings":"AAiEA,OAAO,KAAK,EAAE,aAAa,EAAuB,MAAM,+BAA+B,CAAC;AACxF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAQjD,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAS9E,eAAO,MAAM,gBAAgB,EAAE,WAG9B,CAAC;AAGF,eAAO,MAAM,oBAAoB,EAAE,WAGlC,CAAC;AAQF,eAAO,MAAM,mBAAmB,GAAI,oBAAoB,SAAS,EAAE,iBAAiB,YAAY,KAAG,aAi7BlG,CAAC"}

package/dist/server/mcp-server.js

@@ -1,9 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createRequire } from 'module';
+import { performance } from 'node:perf_hooks';
 import { whoAmI } from '@huggingface/hub';
 import { SpaceSearchTool, formatSearchResults, SEMANTIC_SEARCH_TOOL_CONFIG, ModelSearchTool, MODEL_SEARCH_TOOL_CONFIG, ModelDetailTool, MODEL_DETAIL_TOOL_CONFIG, MODEL_DETAIL_PROMPT_CONFIG, PaperSearchTool, PAPER_SEARCH_TOOL_CONFIG, DatasetSearchTool, DATASET_SEARCH_TOOL_CONFIG, DatasetDetailTool, DATASET_DETAIL_TOOL_CONFIG, DATASET_DETAIL_PROMPT_CONFIG, HUB_INSPECT_TOOL_CONFIG, HubInspectTool, DuplicateSpaceTool, formatDuplicateResult, SpaceInfoTool, formatSpaceInfoResult, SpaceFilesTool, UseSpaceTool, USE_SPACE_TOOL_CONFIG, formatUseSpaceResult, UserSummaryPrompt, USER_SUMMARY_PROMPT_CONFIG, PaperSummaryPrompt, PAPER_SUMMARY_PROMPT_CONFIG, CONFIG_GUIDANCE, TOOL_ID_GROUPS, DOCS_SEMANTIC_SEARCH_CONFIG, DocSearchTool, DOC_FETCH_CONFIG, DocFetchTool, HF_JOBS_TOOL_CONFIG, HfJobsTool, DYNAMIC_SPACE_TOOL_CONFIG, SpaceTool, } from '@llmindset/hf-mcp';
 import { logger } from './utils/logger.js';
-import { logSearchQuery, logPromptQuery, logGradioEvent } from './utils/query-logger.js';
+import { logSearchQuery, logPromptQuery, logGradioEvent, } from './utils/query-logger.js';
 import { DEFAULT_SPACE_TOOLS } from '../shared/settings.js';
 import { extractAuthBouquetAndMix } from './utils/auth-utils.js';
 import { ToolSelectionStrategy } from './utils/tool-selection-strategy.js';
@@ -51,6 +52,31 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             logger.debug({ sessionInfo, options }, 'Query logging options:');
             return options;
         };
+        const runWithQueryLogging = async (logFn, config, work) => {
+            const start = performance.now();
+            try {
+                const result = await work();
+                const durationMs = performance.now() - start;
+                const successOptions = config.successOptions?.(result) ?? {};
+                logFn(config.methodName, config.query, config.parameters, {
+                    ...config.baseOptions,
+                    ...successOptions,
+                    durationMs,
+                    success: true,
+                });
+                return result;
+            }
+            catch (error) {
+                const durationMs = performance.now() - start;
+                logFn(config.methodName, config.query, config.parameters, {
+                    ...config.baseOptions,
+                    durationMs,
+                    success: false,
+                    error,
+                });
+                throw error;
+            }
+        };
         const server = new McpServer({
             name: '@huggingface/mcp-services',
             version: version,
@@ -91,13 +117,19 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             });
         }
         server.prompt(USER_SUMMARY_PROMPT_CONFIG.name, USER_SUMMARY_PROMPT_CONFIG.description, USER_SUMMARY_PROMPT_CONFIG.schema.shape, async (params) => {
-            const userSummary = new UserSummaryPrompt(hfToken);
-            const summaryText = await userSummary.generateSummary(params);
-            logPromptQuery(USER_SUMMARY_PROMPT_CONFIG.name, params.user_id, { user_id: params.user_id }, {
-                ...getLoggingOptions(),
-                totalResults: 1,
-                resultsShared: 1,
-                responseCharCount: summaryText.length,
+            const summaryText = await runWithQueryLogging(logPromptQuery, {
+                methodName: USER_SUMMARY_PROMPT_CONFIG.name,
+                query: params.user_id,
+                parameters: { user_id: params.user_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (text) => ({
+                    totalResults: 1,
+                    resultsShared: 1,
+                    responseCharCount: text.length,
+                }),
+            }, async () => {
+                const userSummary = new UserSummaryPrompt(hfToken);
+                return userSummary.generateSummary(params);
             });
             return {
                 description: `User summary for ${params.user_id}`,
@@ -113,13 +145,19 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             };
         });
         server.prompt(PAPER_SUMMARY_PROMPT_CONFIG.name, PAPER_SUMMARY_PROMPT_CONFIG.description, PAPER_SUMMARY_PROMPT_CONFIG.schema.shape, async (params) => {
-            const paperSummary = new PaperSummaryPrompt(hfToken);
-            const summaryText = await paperSummary.generateSummary(params);
-            logPromptQuery(PAPER_SUMMARY_PROMPT_CONFIG.name, params.paper_id, { paper_id: params.paper_id }, {
-                ...getLoggingOptions(),
-                totalResults: 1,
-                resultsShared: 1,
-                responseCharCount: summaryText.length,
+            const summaryText = await runWithQueryLogging(logPromptQuery, {
+                methodName: PAPER_SUMMARY_PROMPT_CONFIG.name,
+                query: params.paper_id,
+                parameters: { paper_id: params.paper_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (text) => ({
+                    totalResults: 1,
+                    resultsShared: 1,
+                    responseCharCount: text.length,
+                }),
+            }, async () => {
+                const paperSummary = new PaperSummaryPrompt(hfToken);
+                return paperSummary.generateSummary(params);
             });
             return {
                 description: `Paper summary for ${params.paper_id}`,
@@ -135,13 +173,19 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             };
         });
         server.prompt(MODEL_DETAIL_PROMPT_CONFIG.name, MODEL_DETAIL_PROMPT_CONFIG.description, MODEL_DETAIL_PROMPT_CONFIG.schema.shape, async (params) => {
-            const modelDetail = new ModelDetailTool(hfToken, undefined);
-            const result = await modelDetail.getDetails(params.model_id, true);
-            logPromptQuery(MODEL_DETAIL_PROMPT_CONFIG.name, params.model_id, { model_id: params.model_id }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: MODEL_DETAIL_PROMPT_CONFIG.name,
+                query: params.model_id,
+                parameters: { model_id: params.model_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (details) => ({
+                    totalResults: details.totalResults,
+                    resultsShared: details.resultsShared,
+                    responseCharCount: details.formatted.length,
+                }),
+            }, async () => {
+                const modelDetail = new ModelDetailTool(hfToken, undefined);
+                return modelDetail.getDetails(params.model_id, true);
             });
             return {
                 description: `Model details for ${params.model_id}`,
@@ -157,13 +201,19 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             };
         });
         server.prompt(DATASET_DETAIL_PROMPT_CONFIG.name, DATASET_DETAIL_PROMPT_CONFIG.description, DATASET_DETAIL_PROMPT_CONFIG.schema.shape, async (params) => {
-            const datasetDetail = new DatasetDetailTool(hfToken, undefined);
-            const result = await datasetDetail.getDetails(params.dataset_id, true);
-            logPromptQuery(DATASET_DETAIL_PROMPT_CONFIG.name, params.dataset_id, { dataset_id: params.dataset_id }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: DATASET_DETAIL_PROMPT_CONFIG.name,
+                query: params.dataset_id,
+                parameters: { dataset_id: params.dataset_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (details) => ({
+                    totalResults: details.totalResults,
+                    resultsShared: details.resultsShared,
+                    responseCharCount: details.formatted.length,
+                }),
+            }, async () => {
+                const datasetDetail = new DatasetDetailTool(hfToken, undefined);
+                return datasetDetail.getDetails(params.dataset_id, true);
             });
             return {
                 description: `Dataset details for ${params.dataset_id}`,
@@ -179,78 +229,115 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             };
         });
         toolInstances[SEMANTIC_SEARCH_TOOL_CONFIG.name] = server.tool(SEMANTIC_SEARCH_TOOL_CONFIG.name, SEMANTIC_SEARCH_TOOL_CONFIG.description, SEMANTIC_SEARCH_TOOL_CONFIG.schema.shape, SEMANTIC_SEARCH_TOOL_CONFIG.annotations, async (params) => {
-            const semanticSearch = new SpaceSearchTool(hfToken);
-            const searchResult = await semanticSearch.search(params.query, params.limit, params.mcp);
-            const result = formatSearchResults(params.query, searchResult.results, searchResult.totalCount);
-            logSearchQuery(SEMANTIC_SEARCH_TOOL_CONFIG.name, params.query, { limit: params.limit, mcp: params.mcp }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: SEMANTIC_SEARCH_TOOL_CONFIG.name,
+                query: params.query,
+                parameters: { limit: params.limit, mcp: params.mcp },
+                baseOptions: getLoggingOptions(),
+                successOptions: (formatted) => ({
+                    totalResults: formatted.totalResults,
+                    resultsShared: formatted.resultsShared,
+                    responseCharCount: formatted.formatted.length,
+                }),
+            }, async () => {
+                const semanticSearch = new SpaceSearchTool(hfToken);
+                const searchResult = await semanticSearch.search(params.query, params.limit, params.mcp);
+                return formatSearchResults(params.query, searchResult.results, searchResult.totalCount);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[MODEL_SEARCH_TOOL_CONFIG.name] = server.tool(MODEL_SEARCH_TOOL_CONFIG.name, MODEL_SEARCH_TOOL_CONFIG.description, MODEL_SEARCH_TOOL_CONFIG.schema.shape, MODEL_SEARCH_TOOL_CONFIG.annotations, async (params) => {
-            const modelSearch = new ModelSearchTool(hfToken);
-            const result = await modelSearch.searchWithParams(params);
-            logSearchQuery(MODEL_SEARCH_TOOL_CONFIG.name, params.query || `sort:${params.sort || 'trendingScore'}`, params, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: MODEL_SEARCH_TOOL_CONFIG.name,
+                query: params.query || `sort:${params.sort || 'trendingScore'}`,
+                parameters: params,
+                baseOptions: getLoggingOptions(),
+                successOptions: (formatted) => ({
+                    totalResults: formatted.totalResults,
+                    resultsShared: formatted.resultsShared,
+                    responseCharCount: formatted.formatted.length,
+                }),
+            }, async () => {
+                const modelSearch = new ModelSearchTool(hfToken);
+                return modelSearch.searchWithParams(params);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[MODEL_DETAIL_TOOL_CONFIG.name] = server.tool(MODEL_DETAIL_TOOL_CONFIG.name, MODEL_DETAIL_TOOL_CONFIG.description, MODEL_DETAIL_TOOL_CONFIG.schema.shape, MODEL_DETAIL_TOOL_CONFIG.annotations, async (params) => {
-            const modelDetail = new ModelDetailTool(hfToken, undefined);
-            const result = await modelDetail.getDetails(params.model_id, false);
-            logPromptQuery(MODEL_DETAIL_TOOL_CONFIG.name, params.model_id, { model_id: params.model_id }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: MODEL_DETAIL_TOOL_CONFIG.name,
+                query: params.model_id,
+                parameters: { model_id: params.model_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (details) => ({
+                    totalResults: details.totalResults,
+                    resultsShared: details.resultsShared,
+                    responseCharCount: details.formatted.length,
+                }),
+            }, async () => {
+                const modelDetail = new ModelDetailTool(hfToken, undefined);
+                return modelDetail.getDetails(params.model_id, false);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[PAPER_SEARCH_TOOL_CONFIG.name] = server.tool(PAPER_SEARCH_TOOL_CONFIG.name, PAPER_SEARCH_TOOL_CONFIG.description, PAPER_SEARCH_TOOL_CONFIG.schema.shape, PAPER_SEARCH_TOOL_CONFIG.annotations, async (params) => {
-            const result = await new PaperSearchTool(hfToken).search(params.query, params.results_limit, params.concise_only);
-            logSearchQuery(PAPER_SEARCH_TOOL_CONFIG.name, params.query, { results_limit: params.results_limit, concise_only: params.concise_only }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: PAPER_SEARCH_TOOL_CONFIG.name,
+                query: params.query,
+                parameters: { results_limit: params.results_limit, concise_only: params.concise_only },
+                baseOptions: getLoggingOptions(),
+                successOptions: (formatted) => ({
+                    totalResults: formatted.totalResults,
+                    resultsShared: formatted.resultsShared,
+                    responseCharCount: formatted.formatted.length,
+                }),
+            }, async () => {
+                const paperSearchTool = new PaperSearchTool(hfToken);
+                return paperSearchTool.search(params.query, params.results_limit, params.concise_only);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[DATASET_SEARCH_TOOL_CONFIG.name] = server.tool(DATASET_SEARCH_TOOL_CONFIG.name, DATASET_SEARCH_TOOL_CONFIG.description, DATASET_SEARCH_TOOL_CONFIG.schema.shape, DATASET_SEARCH_TOOL_CONFIG.annotations, async (params) => {
-            const datasetSearch = new DatasetSearchTool(hfToken);
-            const result = await datasetSearch.searchWithParams(params);
-            logSearchQuery(DATASET_SEARCH_TOOL_CONFIG.name, params.query || `sort:${params.sort || 'trendingScore'}`, params, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: DATASET_SEARCH_TOOL_CONFIG.name,
+                query: params.query || `sort:${params.sort || 'trendingScore'}`,
+                parameters: params,
+                baseOptions: getLoggingOptions(),
+                successOptions: (formatted) => ({
+                    totalResults: formatted.totalResults,
+                    resultsShared: formatted.resultsShared,
+                    responseCharCount: formatted.formatted.length,
+                }),
+            }, async () => {
+                const datasetSearch = new DatasetSearchTool(hfToken);
+                return datasetSearch.searchWithParams(params);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[DATASET_DETAIL_TOOL_CONFIG.name] = server.tool(DATASET_DETAIL_TOOL_CONFIG.name, DATASET_DETAIL_TOOL_CONFIG.description, DATASET_DETAIL_TOOL_CONFIG.schema.shape, DATASET_DETAIL_TOOL_CONFIG.annotations, async (params) => {
-            const datasetDetail = new DatasetDetailTool(hfToken, undefined);
-            const result = await datasetDetail.getDetails(params.dataset_id, false);
-            logPromptQuery(DATASET_DETAIL_TOOL_CONFIG.name, params.dataset_id, { dataset_id: params.dataset_id }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: DATASET_DETAIL_TOOL_CONFIG.name,
+                query: params.dataset_id,
+                parameters: { dataset_id: params.dataset_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (details) => ({
+                    totalResults: details.totalResults,
+                    resultsShared: details.resultsShared,
+                    responseCharCount: details.formatted.length,
+                }),
+            }, async () => {
+                const datasetDetail = new DatasetDetailTool(hfToken, undefined);
+                return datasetDetail.getDetails(params.dataset_id, false);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
@@ -272,31 +359,43 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             const allowReadme = hasReadmeFlag(currentSelection.enabledToolIds);
             const wantReadme = params.include_readme === true;
             const includeReadme = allowReadme && wantReadme;
-            const tool = new HubInspectTool(hfToken, undefined);
-            const result = await tool.inspect(params, includeReadme);
             const repoIdsParam = params.repo_ids;
             const repoIds = Array.isArray(repoIdsParam) ? repoIdsParam : [];
             const firstRepoId = typeof repoIds[0] === 'string' ? repoIds[0] : '';
             const repoType = params.repo_type;
             const repoTypeSafe = repoType === 'model' || repoType === 'dataset' || repoType === 'space' ? repoType : undefined;
-            logPromptQuery(HUB_INSPECT_TOOL_CONFIG.name, firstRepoId, { count: repoIds.length, repo_type: repoTypeSafe, include_readme: includeReadme }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: HUB_INSPECT_TOOL_CONFIG.name,
+                query: firstRepoId,
+                parameters: { count: repoIds.length, repo_type: repoTypeSafe, include_readme: includeReadme },
+                baseOptions: getLoggingOptions(),
+                successOptions: (details) => ({
+                    totalResults: details.totalResults,
+                    resultsShared: details.resultsShared,
+                    responseCharCount: details.formatted.length,
+                }),
+            }, async () => {
+                const tool = new HubInspectTool(hfToken, undefined);
+                return tool.inspect(params, includeReadme);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
             };
         });
         toolInstances[DOCS_SEMANTIC_SEARCH_CONFIG.name] = server.tool(DOCS_SEMANTIC_SEARCH_CONFIG.name, DOCS_SEMANTIC_SEARCH_CONFIG.description, DOCS_SEMANTIC_SEARCH_CONFIG.schema.shape, DOCS_SEMANTIC_SEARCH_CONFIG.annotations, async (params) => {
-            const docSearch = new DocSearchTool(hfToken);
-            const result = await docSearch.search(params);
-            logSearchQuery(DOCS_SEMANTIC_SEARCH_CONFIG.name, params.query, { product: params.product }, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: DOCS_SEMANTIC_SEARCH_CONFIG.name,
+                query: params.query,
+                parameters: { product: params.product },
+                baseOptions: getLoggingOptions(),
+                successOptions: (formatted) => ({
+                    totalResults: formatted.totalResults,
+                    resultsShared: formatted.resultsShared,
+                    responseCharCount: formatted.formatted.length,
+                }),
+            }, async () => {
+                const docSearch = new DocSearchTool(hfToken);
+                return docSearch.search(params);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
@@ -334,13 +433,19 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
             };
         });
         toolInstances[USE_SPACE_TOOL_CONFIG.name] = server.tool(USE_SPACE_TOOL_CONFIG.name, USE_SPACE_TOOL_CONFIG.description, USE_SPACE_TOOL_CONFIG.schema.shape, USE_SPACE_TOOL_CONFIG.annotations, async (params) => {
-            const useSpaceTool = new UseSpaceTool(hfToken, undefined);
-            const result = await formatUseSpaceResult(useSpaceTool, params);
-            logPromptQuery(USE_SPACE_TOOL_CONFIG.name, params.space_id, { space_id: params.space_id }, {
-                ...getLoggingOptions(),
-                totalResults: result.metadata.totalResults,
-                resultsShared: result.metadata.resultsShared,
-                responseCharCount: result.metadata.formatted.length,
+            const result = await runWithQueryLogging(logPromptQuery, {
+                methodName: USE_SPACE_TOOL_CONFIG.name,
+                query: params.space_id,
+                parameters: { space_id: params.space_id },
+                baseOptions: getLoggingOptions(),
+                successOptions: (useSpaceResult) => ({
+                    totalResults: useSpaceResult.metadata.totalResults,
+                    resultsShared: useSpaceResult.metadata.resultsShared,
+                    responseCharCount: useSpaceResult.metadata.formatted.length,
+                }),
+            }, async () => {
+                const useSpaceTool = new UseSpaceTool(hfToken, undefined);
+                return formatUseSpaceResult(useSpaceTool, params);
             });
             return {
                 content: result.content,
@@ -348,14 +453,20 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
         });
         toolInstances[HF_JOBS_TOOL_CONFIG.name] = server.tool(HF_JOBS_TOOL_CONFIG.name, HF_JOBS_TOOL_CONFIG.description, HF_JOBS_TOOL_CONFIG.schema.shape, HF_JOBS_TOOL_CONFIG.annotations, async (params) => {
             const isAuthenticated = !!hfToken;
-            const jobsTool = new HfJobsTool(hfToken, isAuthenticated, username);
-            const result = await jobsTool.execute(params);
             const loggedOperation = params.operation ?? 'no-operation';
-            logSearchQuery(HF_JOBS_TOOL_CONFIG.name, loggedOperation, params.args || {}, {
-                ...getLoggingOptions(),
-                totalResults: result.totalResults,
-                resultsShared: result.resultsShared,
-                responseCharCount: result.formatted.length,
+            const result = await runWithQueryLogging(logSearchQuery, {
+                methodName: HF_JOBS_TOOL_CONFIG.name,
+                query: loggedOperation,
+                parameters: params.args || {},
+                baseOptions: getLoggingOptions(),
+                successOptions: (jobResult) => ({
+                    totalResults: jobResult.totalResults,
+                    resultsShared: jobResult.resultsShared,
+                    responseCharCount: jobResult.formatted.length,
+                }),
+            }, async () => {
+                const jobsTool = new HfJobsTool(hfToken, isAuthenticated, username);
+                return jobsTool.execute(params);
             });
             return {
                 content: [{ type: 'text', text: result.formatted }],
@@ -373,69 +484,72 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
                     isError: true,
                 };
             }
-            const startTime = Date.now();
-            let success = false;
-            try {
-                const spaceTool = new SpaceTool(hfToken);
-                const result = await spaceTool.execute(params, extra);
-                if ('result' in result && result.result) {
-                    const invokeResult = result;
-                    success = !invokeResult.isError;
-                    const stripImageContent = noImageContentHeaderEnabled || toolSelection.enabledToolIds.includes('NO_GRADIO_IMAGE_CONTENT');
-                    const postProcessOptions = {
-                        stripImageContent,
-                        toolName: DYNAMIC_SPACE_TOOL_CONFIG.name,
-                        outwardFacingName: DYNAMIC_SPACE_TOOL_CONFIG.name,
-                        sessionInfo,
-                        spaceName: params.space_name,
-                    };
-                    const processedResult = applyResultPostProcessing(invokeResult.result, postProcessOptions);
-                    const warningsContent = invokeResult.warnings.length > 0
-                        ? [
-                            {
-                                type: 'text',
-                                text: (invokeResult.warnings.length === 1 ? 'Warning:\n' : 'Warnings:\n') +
-                                    invokeResult.warnings.map((w) => `- ${w}`).join('\n') +
-                                    '\n',
-                            },
-                        ]
-                        : [];
-                    const endTime = Date.now();
-                    const responseContent = [...warningsContent, ...processedResult.content];
-                    logGradioEvent(params.space_name || 'unknown-space', sessionInfo?.clientSessionId || 'unknown', {
-                        durationMs: endTime - startTime,
-                        isAuthenticated: !!hfToken,
-                        clientName: sessionInfo?.clientInfo?.name,
-                        clientVersion: sessionInfo?.clientInfo?.version,
+            const loggedOperation = params.operation ?? 'no-operation';
+            if (params.operation === 'invoke') {
+                const startTime = Date.now();
+                let success = false;
+                try {
+                    const spaceTool = new SpaceTool(hfToken);
+                    const result = await spaceTool.execute(params, extra);
+                    if ('result' in result && result.result) {
+                        const invokeResult = result;
+                        success = !invokeResult.isError;
+                        const stripImageContent = noImageContentHeaderEnabled || toolSelection.enabledToolIds.includes('NO_GRADIO_IMAGE_CONTENT');
+                        const postProcessOptions = {
+                            stripImageContent,
+                            toolName: DYNAMIC_SPACE_TOOL_CONFIG.name,
+                            outwardFacingName: DYNAMIC_SPACE_TOOL_CONFIG.name,
+                            sessionInfo,
+                            spaceName: params.space_name,
+                        };
+                        const processedResult = applyResultPostProcessing(invokeResult.result, postProcessOptions);
+                        const warningsContent = invokeResult.warnings.length > 0
+                            ? [
+                                {
+                                    type: 'text',
+                                    text: (invokeResult.warnings.length === 1 ? 'Warning:\n' : 'Warnings:\n') +
+                                        invokeResult.warnings.map((w) => `- ${w}`).join('\n') +
+                                        '\n',
+                                },
+                            ]
+                            : [];
+                        const durationMs = Date.now() - startTime;
+                        const responseContent = [...warningsContent, ...processedResult.content];
+                        logGradioEvent(params.space_name || 'unknown-space', sessionInfo?.clientSessionId || 'unknown', {
+                            durationMs,
+                            isAuthenticated: !!hfToken,
+                            clientName: sessionInfo?.clientInfo?.name,
+                            clientVersion: sessionInfo?.clientInfo?.version,
+                            success,
+                            error: invokeResult.isError ? 'Tool returned isError=true' : undefined,
+                            responseSizeBytes: JSON.stringify(responseContent).length,
+                            isDynamic: true,
+                        });
+                        return {
+                            content: responseContent,
+                            ...(invokeResult.isError && { isError: true }),
+                        };
+                    }
+                    const toolResult = result;
+                    success = !toolResult.isError;
+                    const durationMs = Date.now() - startTime;
+                    logSearchQuery(DYNAMIC_SPACE_TOOL_CONFIG.name, loggedOperation, params, {
+                        ...getLoggingOptions(),
+                        totalResults: toolResult.totalResults,
+                        resultsShared: toolResult.resultsShared,
+                        responseCharCount: toolResult.formatted.length,
+                        durationMs,
                         success,
-                        error: invokeResult.isError ? 'Tool returned isError=true' : undefined,
-                        responseSizeBytes: JSON.stringify(responseContent).length,
-                        isDynamic: true,
                     });
                     return {
-                        content: responseContent,
-                        ...(invokeResult.isError && { isError: true }),
+                        content: [{ type: 'text', text: toolResult.formatted }],
+                        ...(toolResult.isError && { isError: true }),
                     };
                 }
-                const toolResult = result;
-                success = !toolResult.isError;
-                const loggedOperation = params.operation ?? 'no-operation';
-                logSearchQuery(DYNAMIC_SPACE_TOOL_CONFIG.name, loggedOperation, params, {
-                    ...getLoggingOptions(),
-                    totalResults: toolResult.totalResults,
-                    resultsShared: toolResult.resultsShared,
-                    responseCharCount: toolResult.formatted.length,
-                });
-                return {
-                    content: [{ type: 'text', text: toolResult.formatted }],
-                    ...(toolResult.isError && { isError: true }),
-                };
-            }
-            catch (err) {
-                if (params.operation === 'invoke') {
-                    const endTime = Date.now();
+                catch (err) {
+                    const durationMs = Date.now() - startTime;
                     logGradioEvent(params.space_name || 'unknown-space', sessionInfo?.clientSessionId || 'unknown', {
-                        durationMs: endTime - startTime,
+                        durationMs,
                         isAuthenticated: !!hfToken,
                         clientName: sessionInfo?.clientInfo?.name,
                         clientVersion: sessionInfo?.clientInfo?.version,
@@ -443,9 +557,28 @@ export const createServerFactory = (_webServerInstance, sharedApiClient) => {
                         error: err,
                         isDynamic: true,
                     });
+                    throw err;
                 }
-                throw err;
             }
+            const toolResult = await runWithQueryLogging(logSearchQuery, {
+                methodName: DYNAMIC_SPACE_TOOL_CONFIG.name,
+                query: loggedOperation,
+                parameters: params,
+                baseOptions: getLoggingOptions(),
+                successOptions: (result) => ({
+                    totalResults: result.totalResults,
+                    resultsShared: result.resultsShared,
+                    responseCharCount: result.formatted.length,
+                }),
+            }, async () => {
+                const spaceTool = new SpaceTool(hfToken);
+                const result = await spaceTool.execute(params, extra);
+                return result;
+            });
+            return {
+                content: [{ type: 'text', text: toolResult.formatted }],
+                ...(toolResult.isError && { isError: true }),
+            };
         });
         if (sessionInfo?.clientInfo?.name === 'openai-mcp') {
             logger.debug('Registering Gradio widget resource for skybridge client');