@hubspot/cli 7.6.0-beta.7 → 7.6.0-beta.9

package/lib/prompts/__tests__/createModulePrompt.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createModulePrompt } from '../createModulePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createModulePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when all parameters are provided', () => {
+        it('should return provided values without prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: 'LANDING_PAGE,SITE_PAGE',
+                global: false,
+                availableForNewContent: true,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['LANDING_PAGE', 'SITE_PAGE'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should use default values when optional parameters not provided', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+        it('should parse contentTypes string correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                contentTypes: 'BLOG_POST, EMAIL, LANDING_PAGE',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result.contentTypes).toEqual([
+                'BLOG_POST',
+                'EMAIL',
+                'LANDING_PAGE',
+            ]);
+        });
+    });
+    describe('when some parameters are missing', () => {
+        it('should only prompt for missing parameters', async () => {
+            const commandArgs = {
+                moduleLabel: 'My Module',
+                reactType: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'My Module',
+                reactType: true,
+                contentTypes: ['SITE_PAGE'],
+                global: true,
+                availableForNewContent: false,
+            });
+        });
+    });
+    describe('when no parameters are provided', () => {
+        it('should prompt for all parameters', async () => {
+            mockPromptUser.mockResolvedValue({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'moduleLabel' }),
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'contentTypes' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Prompted Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: true,
+            });
+        });
+    });
+    describe('parameter precedence', () => {
+        it('should prioritize command args over prompted values', async () => {
+            const commandArgs = {
+                moduleLabel: 'Args Module',
+                global: true,
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: false,
+                contentTypes: ['EMAIL'],
+                availableForNewContent: false,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(result).toEqual({
+                moduleLabel: 'Args Module', // from commandArgs
+                reactType: false, // from prompt
+                contentTypes: ['EMAIL'], // from prompt
+                global: true, // from commandArgs
+                availableForNewContent: false, // from prompt
+            });
+        });
+        it('should handle boolean false values correctly', async () => {
+            const commandArgs = {
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: 'ANY',
+                global: false,
+                availableForNewContent: false,
+            };
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                moduleLabel: 'Test Module',
+                reactType: false,
+                contentTypes: ['ANY'],
+                global: false,
+                availableForNewContent: false,
+            });
+        });
+        it('should handle mixed scenario with partial command args and prompting', async () => {
+            const commandArgs = {
+                moduleLabel: 'Partial Module',
+                contentTypes: 'BLOG_POST,BLOG_LISTING',
+            };
+            mockPromptUser.mockResolvedValue({
+                reactType: true,
+                global: false,
+                availableForNewContent: true,
+            });
+            const result = await createModulePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'reactType' }),
+                expect.objectContaining({ name: 'global' }),
+                expect.objectContaining({ name: 'availableForNewContent' }),
+            ]);
+            expect(result).toEqual({
+                moduleLabel: 'Partial Module', // from commandArgs
+                reactType: true, // from prompt
+                contentTypes: ['BLOG_POST', 'BLOG_LISTING'], // from commandArgs (parsed)
+                global: false, // from prompt
+                availableForNewContent: true, // from prompt
+            });
+        });
+    });
+});

package/lib/prompts/__tests__/createTemplatePrompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/prompts/__tests__/createTemplatePrompt.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { createTemplatePrompt } from '../createTemplatePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils.js');
+const mockPromptUser = vi.mocked(promptUser);
+describe('createTemplatePrompt', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('when templateType is provided', () => {
+        it('should return provided templateType without prompting', async () => {
+            const commandArgs = {
+                templateType: 'page-template',
+            };
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should work with different template types', async () => {
+            const testCases = [
+                'email-template',
+                'partial',
+                'global-partial',
+                'blog-listing-template',
+                'blog-post-template',
+                'search-template',
+                'section',
+            ];
+            for (const templateType of testCases) {
+                const commandArgs = { templateType };
+                const result = await createTemplatePrompt(commandArgs);
+                expect(mockPromptUser).not.toHaveBeenCalled();
+                expect(result).toEqual({ templateType });
+                vi.resetAllMocks();
+            }
+        });
+    });
+    describe('when templateType is not provided', () => {
+        it('should prompt for templateType', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'page-template',
+            });
+            const result = await createTemplatePrompt();
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'templateType',
+                    type: 'list',
+                    choices: expect.any(Array),
+                }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'page-template',
+            });
+        });
+        it('should prompt when commandArgs is empty', async () => {
+            mockPromptUser.mockResolvedValue({
+                templateType: 'email-template',
+            });
+            const result = await createTemplatePrompt({});
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'email-template',
+            });
+        });
+        it('should prompt when templateType is undefined', async () => {
+            const commandArgs = {
+                templateType: undefined,
+            };
+            mockPromptUser.mockResolvedValue({
+                templateType: 'partial',
+            });
+            const result = await createTemplatePrompt(commandArgs);
+            expect(mockPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'templateType' }),
+            ]);
+            expect(result).toEqual({
+                templateType: 'partial',
+            });
+        });
+    });
+    describe('integration scenarios', () => {
+        it('should handle mixed usage patterns', async () => {
+            // First call with templateType provided
+            let result = await createTemplatePrompt({
+                templateType: 'blog-post-template',
+            });
+            expect(result.templateType).toBe('blog-post-template');
+            expect(mockPromptUser).not.toHaveBeenCalled();
+            // Second call without templateType
+            mockPromptUser.mockResolvedValue({
+                templateType: 'section',
+            });
+            result = await createTemplatePrompt();
+            expect(result.templateType).toBe('section');
+            expect(mockPromptUser).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/lib/prompts/createFunctionPrompt.d.ts

@@ -1,8 +1,9 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateFunctionPromptResponse = {
     functionsFolder: string;
     filename: string;
     endpointMethod: string;
     endpointPath: string;
 };
-export declare function createFunctionPrompt(): Promise<CreateFunctionPromptResponse>;
+export declare function createFunctionPrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateFunctionPromptResponse>;
 export {};

package/lib/prompts/createFunctionPrompt.js

@@ -55,11 +55,40 @@ const ENDPOINT_PATH_PROMPT = {
         return true;
     },
 };
-export function createFunctionPrompt() {
-    return promptUser([
-        FUNCTIONS_FOLDER_PROMPT,
-        FUNCTION_FILENAME_PROMPT,
-        ENDPOINT_METHOD_PROMPT,
-        ENDPOINT_PATH_PROMPT,
-    ]);
+export function createFunctionPrompt(commandArgs = {}) {
+    // Check if all required parameters are provided (endpointMethod has default)
+    const hasAllRequired = commandArgs.functionsFolder &&
+        commandArgs.filename &&
+        commandArgs.endpointPath;
+    if (hasAllRequired) {
+        return Promise.resolve({
+            functionsFolder: commandArgs.functionsFolder,
+            filename: commandArgs.filename,
+            endpointMethod: commandArgs.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath,
+        });
+    }
+    const prompts = [];
+    // Only prompt for missing parameters
+    if (!commandArgs.functionsFolder) {
+        prompts.push(FUNCTIONS_FOLDER_PROMPT);
+    }
+    if (!commandArgs.filename) {
+        prompts.push(FUNCTION_FILENAME_PROMPT);
+    }
+    if (!commandArgs.endpointMethod) {
+        prompts.push(ENDPOINT_METHOD_PROMPT);
+    }
+    if (!commandArgs.endpointPath) {
+        prompts.push(ENDPOINT_PATH_PROMPT);
+    }
+    return promptUser(prompts).then(promptResponse => {
+        // Merge prompted values with provided commandArgs
+        return {
+            functionsFolder: commandArgs.functionsFolder || promptResponse.functionsFolder,
+            filename: commandArgs.filename || promptResponse.filename,
+            endpointMethod: commandArgs.endpointMethod || promptResponse.endpointMethod || 'GET',
+            endpointPath: commandArgs.endpointPath || promptResponse.endpointPath,
+        };
+    });
 }

package/lib/prompts/createModulePrompt.d.ts

@@ -1,3 +1,4 @@
+import { CreateArgs } from '../../types/Cms.js';
 type CreateModulePromptResponse = {
     moduleLabel: string;
     reactType: boolean;
@@ -5,5 +6,5 @@ type CreateModulePromptResponse = {
     global: boolean;
     availableForNewContent: boolean;
 };
-export declare function createModulePrompt(): Promise<CreateModulePromptResponse>;
+export declare function createModulePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateModulePromptResponse>;
 export {};

package/lib/prompts/createModulePrompt.js

@@ -58,7 +58,54 @@ const AVAILABLE_FOR_NEW_CONTENT = {
     message: i18n(`lib.prompts.createModulePrompt.availableForNewContent`),
     default: true,
 };
-export function createModulePrompt() {
+export function createModulePrompt(commandArgs = {}) {
+    // Check if moduleLabel is provided (main requirement to skip full prompting)
+    // but still allow individual parameter prompting for enhanced UX
+    if (commandArgs.moduleLabel) {
+        const prompts = [];
+        // Only prompt for parameters not explicitly provided
+        if (commandArgs.reactType === undefined) {
+            prompts.push(REACT_TYPE_PROMPT);
+        }
+        if (!commandArgs.contentTypes) {
+            prompts.push(CONTENT_TYPES_PROMPT);
+        }
+        if (commandArgs.global === undefined) {
+            prompts.push(GLOBAL_PROMPT);
+        }
+        if (commandArgs.availableForNewContent === undefined) {
+            prompts.push(AVAILABLE_FOR_NEW_CONTENT);
+        }
+        // If no additional prompts needed, return with defaults
+        if (prompts.length === 0) {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : ['ANY'];
+            return Promise.resolve({
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ?? true,
+            });
+        }
+        // Prompt only for missing optional parameters
+        return promptUser(prompts).then(promptResponse => {
+            const contentTypesArray = commandArgs.contentTypes
+                ? commandArgs.contentTypes.split(',').map((t) => t.trim())
+                : promptResponse.contentTypes || ['ANY'];
+            return {
+                moduleLabel: commandArgs.moduleLabel,
+                reactType: commandArgs.reactType ?? promptResponse.reactType ?? false,
+                contentTypes: contentTypesArray,
+                global: commandArgs.global ?? promptResponse.global ?? false,
+                availableForNewContent: commandArgs.availableForNewContent ??
+                    promptResponse.availableForNewContent ??
+                    true,
+            };
+        });
+    }
+    // No moduleLabel provided, prompt for everything (original behavior)
     return promptUser([
         MODULE_LABEL_PROMPT,
         REACT_TYPE_PROMPT,

package/lib/prompts/createTemplatePrompt.d.ts

@@ -1,27 +1,6 @@
-declare const templateTypeChoices: [{
-    readonly name: "page";
-    readonly value: "page-template";
-}, {
-    readonly name: "email";
-    readonly value: "email-template";
-}, {
-    readonly name: "partial";
-    readonly value: "partial";
-}, {
-    readonly name: "global partial";
-    readonly value: "global-partial";
-}, {
-    readonly name: "blog listing";
-    readonly value: "blog-listing-template";
-}, {
-    readonly name: "blog post";
-    readonly value: "blog-post-template";
-}, {
-    readonly name: "search results";
-    readonly value: "search-template";
-}];
+import { CreateArgs, TemplateType } from '../../types/Cms.js';
 interface CreateTemplatePromptResponse {
-    templateType: (typeof templateTypeChoices)[number]['value'];
+    templateType: TemplateType;
 }
-export declare function createTemplatePrompt(): Promise<CreateTemplatePromptResponse>;
+export declare function createTemplatePrompt(commandArgs?: Partial<CreateArgs>): Promise<CreateTemplatePromptResponse>;
 export {};

package/lib/prompts/createTemplatePrompt.js

@@ -8,6 +8,7 @@ const templateTypeChoices = [
     { name: 'blog listing', value: 'blog-listing-template' },
     { name: 'blog post', value: 'blog-post-template' },
     { name: 'search results', value: 'search-template' },
+    { name: 'section', value: 'section' },
 ];
 const TEMPLATE_TYPE_PROMPT = {
     type: 'list',
@@ -16,6 +17,13 @@ const TEMPLATE_TYPE_PROMPT = {
     default: 'page',
     choices: templateTypeChoices,
 };
-export function createTemplatePrompt() {
+export function createTemplatePrompt(commandArgs = {}) {
+    // If templateType is provided, return it directly
+    if (commandArgs.templateType) {
+        return Promise.resolve({
+            templateType: commandArgs.templateType,
+        });
+    }
+    // No templateType provided, prompt for it (original behavior)
     return promptUser([TEMPLATE_TYPE_PROMPT]);
 }

package/mcp-server/tools/index.js

@@ -5,6 +5,8 @@ import { DeployProjectTool } from './project/DeployProjectTool.js';
 import { AddFeatureToProjectTool } from './project/AddFeatureToProjectTool.js';
 import { ValidateProjectTool } from './project/ValidateProjectTool.js';
 import { GetConfigValuesTool } from './project/GetConfigValuesTool.js';
+import { DocsSearchTool } from './project/DocsSearchTool.js';
+import { DocFetchTool } from './project/DocFetchTool.js';
 export function registerProjectTools(mcpServer) {
     return [
         new UploadProjectTools(mcpServer).register(),
@@ -14,5 +16,7 @@ export function registerProjectTools(mcpServer) {
         new AddFeatureToProjectTool(mcpServer).register(),
         new ValidateProjectTool(mcpServer).register(),
         new GetConfigValuesTool(mcpServer).register(),
+        new DocsSearchTool(mcpServer).register(),
+        new DocFetchTool(mcpServer).register(),
     ];
 }

package/mcp-server/tools/project/DocFetchTool.d.ts

@@ -0,0 +1,17 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docUrl: string;
+}, {
+    docUrl: string;
+}>;
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocFetchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docUrl }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

package/mcp-server/tools/project/DocFetchTool.js

@@ -0,0 +1,49 @@
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docUrl } from './constants.js';
+import { http } from '@hubspot/local-dev-lib/http/unauthed';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docUrl,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'fetch-hubspot-doc';
+export class DocFetchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docUrl }) {
+        await trackToolUsage(toolName);
+        try {
+            // Append .md extension to the URL
+            const markdownUrl = `${docUrl}.md`;
+            const response = await http.get({
+                url: markdownUrl,
+            });
+            const content = response.data;
+            if (!content || content.trim().length === 0) {
+                return formatTextContents('Document is empty or contains no content.');
+            }
+            return formatTextContents(content);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error fetching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch a single HubSpot Developer Documentation file',
+            description: 'Fetch a single HubSpot Developer Documentation file by URL. Call after search-hubspot-docs.',
+            inputSchema,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/project/DocsSearchTool.d.ts

@@ -0,0 +1,26 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    docsSearchQuery: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    docsSearchQuery: string;
+}, {
+    docsSearchQuery: string;
+}>;
+export interface DocsSearchResponse {
+    results: {
+        title: string;
+        content: string;
+        description: string;
+        url: string;
+        score: number;
+    }[];
+}
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocsSearchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docsSearchQuery, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

package/mcp-server/tools/project/DocsSearchTool.js

@@ -0,0 +1,62 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import z from 'zod';
+import { Tool } from '../../types.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { docsSearchQuery } from './constants.js';
+import { getAccountId, getConfigPath, loadConfig, } from '@hubspot/local-dev-lib/config';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+const inputSchema = {
+    docsSearchQuery,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'search-hubspot-docs';
+export class DocsSearchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docsSearchQuery, }) {
+        await trackToolUsage(toolName, { mode: docsSearchQuery });
+        loadConfig(getConfigPath());
+        const accountId = getAccountId();
+        if (!accountId) {
+            const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
+            return formatTextContents(authErrorMessage);
+        }
+        try {
+            const response = await http.post(accountId, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: docsSearchQuery,
+                },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return formatTextContents('No documentation found for your query.');
+            }
+            const formattedResults = results
+                .map(result => `**${result.title}**\n${result.description}\nURL: ${result.url}\nScore: ${result.score}\n\n${result.content}\n---\n`)
+                .join('\n');
+            const successMessage = `Found ${results.length} documentation results:\n\n${formattedResults}`;
+            return formatTextContents(successMessage);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle different status codes
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error searching documentation: ${error instanceof Error ? error.message : String(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Search the HubSpot docs',
+            description: 'Search the HubSpot docs for information. This will return results that include a url to be used in fetch-hubspot-doc.',
+            inputSchema,
+        }, this.handler);
+    }
+}