sfcc-dev-mcp 1.0.15 → 1.0.19

package/src/core/handlers/abstract-client-handler.ts

@@ -0,0 +1,85 @@
+import { BaseToolHandler, ToolExecutionContext, GenericToolSpec, HandlerContext, ToolArguments } from './base-handler.js';
+import { ClientFactory } from './client-factory.js';
+
+/**
+ * Abstract base class for handlers that need a client with factory-based creation.
+ * This provides a simpler alternative to SimpleClientHandler when you need
+ * access to ClientFactory for more complex client creation scenarios.
+ *
+ * Use this when:
+ * - Your client needs ClientFactory for creation (e.g., requires config/credentials)
+ * - You need a simple single-client handler pattern
+ *
+ * Use SimpleClientHandler when:
+ * - Your client has a simple constructor with no dependencies
+ * - You want the most minimal boilerplate
+ */
+export abstract class AbstractClientHandler<TToolName extends string, TClient> extends BaseToolHandler<TToolName> {
+  protected client: TClient | null = null;
+  protected clientFactory: ClientFactory;
+
+  constructor(context: HandlerContext, subLoggerName: string) {
+    super(context, subLoggerName);
+    this.clientFactory = new ClientFactory(context, this.logger);
+  }
+
+  /**
+   * Create the client for this handler.
+   * Returns null if the client cannot be created (e.g., missing credentials).
+   */
+  protected abstract createClient(): TClient | null;
+
+  /**
+   * Get the context key used to expose the client in the execution context.
+   */
+  protected abstract getClientContextKey(): string;
+
+  /**
+   * Get a descriptive name for the client (used in logging and error messages).
+   */
+  protected abstract getClientDisplayName(): string;
+
+  /**
+   * Get the error message when the client is not available.
+   * Override this for custom error messages.
+   */
+  protected getClientRequiredError(): string {
+    return `${this.getClientDisplayName()} client not initialized`;
+  }
+
+  protected async onInitialize(): Promise<void> {
+    this.client = this.createClient();
+    if (this.client) {
+      this.logger.debug(`${this.getClientDisplayName()} client initialized`);
+    }
+  }
+
+  protected async onDispose(): Promise<void> {
+    this.client = null;
+    this.logger.debug(`${this.getClientDisplayName()} client disposed`);
+  }
+
+  protected async createExecutionContext(): Promise<ToolExecutionContext> {
+    if (!this.client) {
+      throw new Error(this.getClientRequiredError());
+    }
+
+    return {
+      handlerContext: this.context,
+      logger: this.logger,
+      [this.getClientContextKey()]: this.client,
+    };
+  }
+
+  /**
+   * Abstract method to get tool configuration.
+   * Each concrete handler implements this with their specific config.
+   */
+  protected abstract getToolConfig(): Record<TToolName, GenericToolSpec<ToolArguments, any>>;
+
+  /**
+   * Abstract method to get tool name set for O(1) lookup.
+   * Each concrete handler implements this with their specific tool set.
+   */
+  protected abstract getToolNameSet(): Set<TToolName>;
+}

package/src/core/handlers/agent-instructions-handler.ts

@@ -0,0 +1,48 @@
+import { HandlerContext, ToolExecutionContext } from './base-handler.js';
+import { SimpleClientHandler } from './simple-client-handler.js';
+import { AgentInstructionsClient } from '../../clients/agent-instructions-client.js';
+import { InstructionAdvisor } from '../instruction-advisor.js';
+import {
+  AGENT_INSTRUCTION_TOOL_CONFIG,
+  AgentInstructionToolName,
+  AGENT_INSTRUCTION_TOOL_NAMES_SET,
+} from '../../tool-configs/agent-instructions-tool-config.js';
+import { WorkspaceRootsService } from '../../config/workspace-roots.js';
+
+/**
+ * Handler for installing/merging AGENTS.md and skills into the user's project
+ */
+export class AgentInstructionsToolHandler extends SimpleClientHandler<
+  AgentInstructionToolName,
+  AgentInstructionsClient
+> {
+  private readonly instructionAdvisor: InstructionAdvisor;
+  private agentInstructionsClient: AgentInstructionsClient | null = null;
+
+  constructor(context: HandlerContext) {
+    const rootsService = context.workspaceRootsService ?? new WorkspaceRootsService(context.logger);
+    const client = new AgentInstructionsClient(rootsService);
+    super(context, 'AgentInstructions', {
+      toolConfig: AGENT_INSTRUCTION_TOOL_CONFIG,
+      toolNameSet: AGENT_INSTRUCTION_TOOL_NAMES_SET,
+      clientContextKey: 'agentInstructionsClient',
+      clientDisplayName: 'Agent instructions',
+      createClient: () => {
+        this.agentInstructionsClient = client;
+        return client;
+      },
+    });
+    this.instructionAdvisor = new InstructionAdvisor(client, context.logger);
+  }
+
+  /**
+   * Override to add instructionAdvisor to execution context
+   */
+  protected override async createExecutionContext(): Promise<ToolExecutionContext> {
+    const baseContext = await super.createExecutionContext();
+    return {
+      ...baseContext,
+      instructionAdvisor: this.instructionAdvisor,
+    };
+  }
+}

package/src/core/handlers/base-handler.ts

@@ -1,5 +1,6 @@
 import { Logger } from '../../utils/logger.js';
 import { SFCCConfig } from '../../types/types.js';
+import { WorkspaceRootsService } from '../../config/workspace-roots.js';
 
 export interface HandlerContext {
   logger: Logger;
@@ -8,6 +9,7 @@ export interface HandlerContext {
     canAccessLogs: boolean;
     canAccessOCAPI: boolean;
   };
+  workspaceRootsService?: WorkspaceRootsService;
 }
 
 export interface ToolExecutionResult {
@@ -20,30 +22,21 @@ export interface ToolArguments {
 }
 
 /**
- * Generic tool specification interface
- * Defines the contract for declarative tool configuration
+ * Generic tool specification interface for declarative tool configuration
  */
 export interface GenericToolSpec<TArgs = ToolArguments, TResult = any> {
-  /** Optional validation function for tool arguments */
   validate?: (args: TArgs, toolName: string) => void;
-  /** Optional function to apply default values to arguments */
   defaults?: (args: TArgs) => Partial<TArgs>;
-  /** Main execution function for the tool */
   exec: (args: TArgs, context: ToolExecutionContext) => Promise<TResult>;
-  /** Function to generate log message for the tool execution */
   logMessage: (args: TArgs) => string;
 }
 
 /**
  * Context provided to tool execution functions
- * Allows tools to access clients and other resources
  */
 export interface ToolExecutionContext {
-  /** Handler context with configuration and capabilities */
   handlerContext: HandlerContext;
-  /** Logger instance for the handler */
   logger: any;
-  /** Additional context data that can be provided by concrete handlers */
   [key: string]: any;
 }
 
@@ -69,43 +62,20 @@ export abstract class BaseToolHandler<TToolName extends string = string> {
     this.logger = Logger.getChildLogger(`Handler:${subLoggerName}`);
   }
 
-  /**
-   * Abstract method to get tool configuration
-   * Each concrete handler implements this with their specific config
-   */
   protected abstract getToolConfig(): Record<TToolName, GenericToolSpec>;
-
-  /**
-   * Abstract method to get tool name set for O(1) lookup
-   * Each concrete handler implements this with their specific tool set
-   */
   protected abstract getToolNameSet(): Set<string>;
-
-  /**
-   * Abstract method to create execution context
-   * Each concrete handler can provide specialized context
-   */
   protected abstract createExecutionContext(): Promise<ToolExecutionContext>;
 
-  /**
-   * Check if this handler can handle the given tool
-   */
   canHandle(toolName: string): boolean {
     return this.getToolNameSet().has(toolName);
   }
 
-  /**
-   * Config-driven tool execution
-   * Handles validation, defaults, execution, and logging uniformly
-   */
   async handle(toolName: string, args: ToolArguments, startTime: number): Promise<ToolExecutionResult> {
     if (!this.canHandle(toolName)) {
       throw new Error(`Unsupported tool: ${toolName}`);
     }
 
-    const toolConfig = this.getToolConfig();
-    const spec = toolConfig[toolName as TToolName];
-
+    const spec = this.getToolConfig()[toolName as TToolName];
     if (!spec) {
       throw new Error(`No configuration found for tool: ${toolName}`);
     }
@@ -118,80 +88,36 @@ export abstract class BaseToolHandler<TToolName extends string = string> {
     );
   }
 
-  /**
-   * Generic tool dispatch using configuration
-   * Handles validation, defaults, and execution
-   */
   private async dispatchTool(spec: GenericToolSpec, args: ToolArguments): Promise<any> {
     const context = await this.createExecutionContext();
-    const processedArgs = this.createValidatedArgs(spec, args, 'tool');
-
-    return spec.exec(processedArgs, context);
-  }
-
-  /**
-   * Apply default values to arguments
-   */
-  private applyDefaults(spec: GenericToolSpec, args: ToolArguments): ToolArguments {
-    if (!spec.defaults) {
-      return args;
-    }
-
-    const defaults = spec.defaults(args);
-    return { ...args, ...defaults };
-  }
-
-  /**
-   * Create validated arguments with defaults applied
-   */
-  private createValidatedArgs(spec: GenericToolSpec, args: ToolArguments, toolName: string): ToolArguments {
-    // Apply defaults first
     const processedArgs = this.applyDefaults(spec, args);
 
-    // Validate if validator exists
     if (spec.validate) {
-      spec.validate(processedArgs, toolName);
+      spec.validate(processedArgs, 'tool');
     }
 
-    return processedArgs;
+    return spec.exec(processedArgs, context);
+  }
+
+  private applyDefaults(spec: GenericToolSpec, args: ToolArguments): ToolArguments {
+    return spec.defaults ? { ...args, ...spec.defaults(args) } : args;
   }
 
-  /**
-   * Initialize the handler (lazy initialization)
-   */
   protected async initialize(): Promise<void> {
-    if (this._isInitialized) {
-      return;
-    }
+    if (this._isInitialized) { return; }
     await this.onInitialize();
     this._isInitialized = true;
   }
 
-  /**
-   * Override this method for custom initialization logic
-   */
-  protected async onInitialize(): Promise<void> {
-    // Default: no-op
-  }
+  protected async onInitialize(): Promise<void> { /* no-op */ }
 
-  /**
-   * Clean up resources when handler is destroyed
-   */
   async dispose(): Promise<void> {
     await this.onDispose();
     this._isInitialized = false;
   }
 
-  /**
-   * Override this method for custom cleanup logic
-   */
-  protected async onDispose(): Promise<void> {
-    // Default: no-op
-  }
+  protected async onDispose(): Promise<void> { /* no-op */ }
 
-  /**
-   * Validate required arguments
-   */
   protected validateArgs(args: ToolArguments, required: string[], toolName: string): void {
     for (const field of required) {
       if (!args?.[field]) {
@@ -205,39 +131,21 @@ export abstract class BaseToolHandler<TToolName extends string = string> {
     }
   }
 
-  /**
-   * Create a standardized response
-   */
   protected createResponse(data: any, stringify: boolean = true): ToolExecutionResult {
     return {
-      content: [
-        { type: 'text', text: stringify ? JSON.stringify(data, null, 2) : data },
-      ],
+      content: [{ type: 'text', text: stringify ? JSON.stringify(data, null, 2) : data }],
       isError: false,
     };
   }
 
-  /**
-   * Create an error response
-   */
   protected createErrorResponse(error: Error, toolName: string): ToolExecutionResult {
     this.logger.error(`Error in ${toolName}:`, error);
     return {
-      content: [
-        {
-          type: 'text',
-          text: error instanceof HandlerError
-            ? `Error: ${error.message}`
-            : `Error: ${error.message}`,
-        },
-      ],
+      content: [{ type: 'text', text: `Error: ${error.message}` }],
       isError: true,
     };
   }
 
-  /**
-   * Execute a tool operation with standardized logging and error handling
-   */
   protected async executeWithLogging(
     toolName: string,
     startTime: number,
@@ -246,19 +154,13 @@ export abstract class BaseToolHandler<TToolName extends string = string> {
   ): Promise<ToolExecutionResult> {
     try {
       await this.initialize();
-
-      if (logMessage) {
-        this.logger.debug(logMessage);
-      }
+      if (logMessage) { this.logger.debug(logMessage); }
 
       const result = await operation();
       this.logger.timing(toolName, startTime);
-
-      // Log result metadata for debugging
-      this.logger.debug(`${toolName} completed successfully`, {
+      this.logger.debug(`${toolName} completed`, {
         resultType: typeof result,
         resultLength: Array.isArray(result) ? result.length : undefined,
-        hasData: result != null,
       });
 
       return this.createResponse(result);
@@ -267,16 +169,4 @@ export abstract class BaseToolHandler<TToolName extends string = string> {
       return this.createErrorResponse(error as Error, toolName);
     }
   }
-
-  /**
-   * @deprecated Use executeWithLogging instead
-   */
-  protected async wrap(
-    toolName: string,
-    startTime: number,
-    fn: () => Promise<any>,
-    logMessage?: string,
-  ): Promise<ToolExecutionResult> {
-    return this.executeWithLogging(toolName, startTime, fn, logMessage);
-  }
 }

package/src/core/handlers/cartridge-handler.ts

@@ -1,6 +1,6 @@
-import { BaseToolHandler, ToolExecutionContext, GenericToolSpec, HandlerContext, ToolArguments } from './base-handler.js';
-import { CartridgeGenerationClient } from '../../clients/cartridge-generation-client.js';
-import { ClientFactory } from './client-factory.js';
+import { GenericToolSpec, ToolArguments, HandlerContext } from './base-handler.js';
+import { AbstractClientHandler } from './abstract-client-handler.js';
+import { CartridgeGenerationClient } from '../../clients/cartridge/index.js';
 import {
   CARTRIDGE_TOOL_CONFIG,
   CartridgeToolName,
@@ -8,51 +8,31 @@ import {
 } from '../../tool-configs/cartridge-tool-config.js';
 
 /**
- * Handler for cartridge generation tools using config-driven dispatch
- * Provides automated cartridge structure creation with complete project setup
+ * Handler for cartridge generation tools using config-driven dispatch.
+ * Provides automated cartridge structure creation with complete project setup.
  */
-export class CartridgeToolHandler extends BaseToolHandler<CartridgeToolName> {
-  private cartridgeClient: CartridgeGenerationClient | null = null;
-  private clientFactory: ClientFactory;
-
+export class CartridgeToolHandler extends AbstractClientHandler<CartridgeToolName, CartridgeGenerationClient> {
   constructor(context: HandlerContext, subLoggerName: string) {
     super(context, subLoggerName);
-    this.clientFactory = new ClientFactory(context, this.logger);
   }
 
-  protected async onInitialize(): Promise<void> {
-    if (!this.cartridgeClient) {
-      this.cartridgeClient = this.clientFactory.createCartridgeClient();
-      this.logger.debug('Cartridge generation client initialized');
-    }
+  protected createClient(): CartridgeGenerationClient {
+    return this.clientFactory.createCartridgeClient();
   }
 
-  protected async onDispose(): Promise<void> {
-    this.cartridgeClient = null;
-    this.logger.debug('Cartridge generation client disposed');
+  protected getClientContextKey(): string {
+    return 'cartridgeClient';
   }
 
-  canHandle(toolName: string): boolean {
-    return CARTRIDGE_TOOL_NAMES_SET.has(toolName as CartridgeToolName);
+  protected getClientDisplayName(): string {
+    return 'Cartridge Generation';
   }
 
   protected getToolNameSet(): Set<CartridgeToolName> {
     return CARTRIDGE_TOOL_NAMES_SET;
   }
 
-  protected getToolConfig(): Record<string, GenericToolSpec<ToolArguments, any>> {
+  protected getToolConfig(): Record<CartridgeToolName, GenericToolSpec<ToolArguments, any>> {
     return CARTRIDGE_TOOL_CONFIG;
   }
-
-  protected async createExecutionContext(): Promise<ToolExecutionContext> {
-    if (!this.cartridgeClient) {
-      throw new Error('Cartridge generation client not initialized');
-    }
-
-    return {
-      handlerContext: this.context,
-      logger: this.logger,
-      cartridgeClient: this.cartridgeClient,
-    };
-  }
 }

package/src/core/handlers/client-factory.ts

@@ -2,7 +2,8 @@ import { HandlerContext } from './base-handler.js';
 import { SFCCLogClient } from '../../clients/log-client.js';
 import { OCAPIClient } from '../../clients/ocapi-client.js';
 import { OCAPICodeVersionsClient } from '../../clients/ocapi/code-versions-client.js';
-import { CartridgeGenerationClient } from '../../clients/cartridge-generation-client.js';
+import { CartridgeGenerationClient } from '../../clients/cartridge/index.js';
+import { ScriptDebuggerClient } from '../../clients/script-debugger/index.js';
 import { Logger } from '../../utils/logger.js';
 import { IFileSystemService, IPathService, FileSystemService, PathService } from '../../services/index.js';
 
@@ -94,15 +95,44 @@ export class ClientFactory {
     );
   }
 
+  /**
+   * Create a Script Debugger Client if full credentials are available
+   */
+  createScriptDebuggerClient(): ScriptDebuggerClient | null {
+    if (!this.hasScriptDebuggerAccess()) {
+      this.logger.debug('Script Debugger client not created: missing credentials');
+      return null;
+    }
+
+    this.logger.debug('Creating Script Debugger Client');
+    return new ScriptDebuggerClient(this.context.config!, this.logger);
+  }
+
+  /**
+   * Check if Script Debugger access is available
+   * Requires hostname and either basic auth or client credentials
+   */
+  private hasScriptDebuggerAccess(): boolean {
+    const config = this.context.config;
+    if (!config?.hostname) {return false;}
+
+    const hasBasicAuth = !!(config.username && config.password);
+    const hasClientAuth = !!(config.clientId && config.clientSecret);
+
+    return hasBasicAuth || hasClientAuth;
+  }
+
   /**
    * Get the required error message for a client type
    */
-  static getClientRequiredError(clientType: 'OCAPI' | 'Log'): string {
+  static getClientRequiredError(clientType: 'OCAPI' | 'Log' | 'ScriptDebugger'): string {
     switch (clientType) {
       case 'OCAPI':
         return 'OCAPI client not configured - ensure credentials are provided in full mode.';
       case 'Log':
         return 'Log client not configured - ensure log access is enabled.';
+      case 'ScriptDebugger':
+        return 'Script Debugger client not configured - ensure SFCC credentials (hostname + username/password or clientId/clientSecret) are provided.';
       default:
         return 'Required client not configured.';
     }

package/src/core/handlers/code-version-handler.ts

@@ -1,6 +1,7 @@
-import { BaseToolHandler, ToolExecutionContext, GenericToolSpec, HandlerContext, ToolArguments } from './base-handler.js';
-import { OCAPICodeVersionsClient } from '../../clients/ocapi/code-versions-client.js';
+import { GenericToolSpec, ToolArguments, HandlerContext } from './base-handler.js';
+import { AbstractClientHandler } from './abstract-client-handler.js';
 import { ClientFactory } from './client-factory.js';
+import { OCAPICodeVersionsClient } from '../../clients/ocapi/code-versions-client.js';
 import {
   CODE_VERSION_TOOL_CONFIG,
   CodeVersionToolName,
@@ -8,51 +9,35 @@ import {
 } from '../../tool-configs/code-version-tool-config.js';
 
 /**
- * Handler for code version management tools using config-driven dispatch
- * Provides code version listing, activation, and deployment management
+ * Handler for code version management tools using config-driven dispatch.
+ * Provides code version listing, activation, and deployment management.
  */
-export class CodeVersionToolHandler extends BaseToolHandler<CodeVersionToolName> {
-  private codeVersionsClient: OCAPICodeVersionsClient | null = null;
-  private clientFactory: ClientFactory;
-
+export class CodeVersionToolHandler extends AbstractClientHandler<CodeVersionToolName, OCAPICodeVersionsClient> {
   constructor(context: HandlerContext, subLoggerName: string) {
     super(context, subLoggerName);
-    this.clientFactory = new ClientFactory(context, this.logger);
   }
 
-  protected async onInitialize(): Promise<void> {
-    this.codeVersionsClient = this.clientFactory.createCodeVersionsClient();
-    if (this.codeVersionsClient) {
-      this.logger.debug('Code versions client initialized');
-    }
+  protected createClient(): OCAPICodeVersionsClient | null {
+    return this.clientFactory.createCodeVersionsClient();
+  }
+
+  protected getClientContextKey(): string {
+    return 'codeVersionsClient';
   }
 
-  protected async onDispose(): Promise<void> {
-    this.codeVersionsClient = null;
-    this.logger.debug('Code versions client disposed');
+  protected getClientDisplayName(): string {
+    return 'OCAPI (Code Versions)';
   }
 
-  canHandle(toolName: string): boolean {
-    return CODE_VERSION_TOOL_NAMES_SET.has(toolName as CodeVersionToolName);
+  protected getClientRequiredError(): string {
+    return ClientFactory.getClientRequiredError('OCAPI');
   }
 
   protected getToolNameSet(): Set<CodeVersionToolName> {
     return CODE_VERSION_TOOL_NAMES_SET;
   }
 
-  protected getToolConfig(): Record<string, GenericToolSpec<ToolArguments, any>> {
+  protected getToolConfig(): Record<CodeVersionToolName, GenericToolSpec<ToolArguments, any>> {
     return CODE_VERSION_TOOL_CONFIG;
   }
-
-  protected async createExecutionContext(): Promise<ToolExecutionContext> {
-    if (!this.codeVersionsClient) {
-      throw new Error(ClientFactory.getClientRequiredError('OCAPI'));
-    }
-
-    return {
-      handlerContext: this.context,
-      logger: this.logger,
-      codeVersionsClient: this.codeVersionsClient,
-    };
-  }
 }

package/src/core/handlers/docs-handler.ts

@@ -1,51 +1,19 @@
-import { BaseToolHandler, ToolExecutionContext, GenericToolSpec, ToolArguments, HandlerContext } from './base-handler.js';
+import { HandlerContext } from './base-handler.js';
+import { SimpleClientHandler } from './simple-client-handler.js';
 import { SFCCDocumentationClient } from '../../clients/docs-client.js';
 import { DOCS_TOOL_CONFIG, DocToolName, DOC_TOOL_NAMES_SET } from '../../tool-configs/docs-tool-config.js';
 
 /**
- * Handler for SFCC documentation tools using config-driven dispatch
- * Provides access to SFCC class information, search, and documentation
+ * Handler for SFCC documentation tools
  */
-export class DocsToolHandler extends BaseToolHandler<DocToolName> {
-  private docsClient: SFCCDocumentationClient | null = null;
-
-  constructor(context: HandlerContext, subLoggerName: string) {
-    super(context, subLoggerName);
-  }
-
-  protected async onInitialize(): Promise<void> {
-    if (!this.docsClient) {
-      this.docsClient = new SFCCDocumentationClient();
-      this.logger.debug('Documentation client initialized');
-    }
-  }
-
-  protected async onDispose(): Promise<void> {
-    this.docsClient = null;
-    this.logger.debug('Documentation client disposed');
-  }
-
-  canHandle(toolName: string): boolean {
-    return DOC_TOOL_NAMES_SET.has(toolName as DocToolName);
-  }
-
-  protected getToolNameSet(): Set<DocToolName> {
-    return DOC_TOOL_NAMES_SET;
-  }
-
-  protected getToolConfig(): Record<string, GenericToolSpec<ToolArguments, any>> {
-    return DOCS_TOOL_CONFIG;
-  }
-
-  protected async createExecutionContext(): Promise<ToolExecutionContext> {
-    if (!this.docsClient) {
-      throw new Error('Documentation client not initialized');
-    }
-
-    return {
-      handlerContext: this.context,
-      logger: this.logger,
-      docsClient: this.docsClient,
-    };
+export class DocsToolHandler extends SimpleClientHandler<DocToolName, SFCCDocumentationClient> {
+  constructor(context: HandlerContext) {
+    super(context, 'Docs', {
+      toolConfig: DOCS_TOOL_CONFIG,
+      toolNameSet: DOC_TOOL_NAMES_SET,
+      clientContextKey: 'docsClient',
+      clientDisplayName: 'Documentation',
+      createClient: () => new SFCCDocumentationClient(),
+    });
   }
 }

package/src/core/handlers/isml-handler.ts

@@ -0,0 +1,19 @@
+import { HandlerContext } from './base-handler.js';
+import { SimpleClientHandler } from './simple-client-handler.js';
+import { ISMLClient } from '../../clients/isml-client.js';
+import { ISML_TOOL_CONFIG, ISMLToolName, ISML_TOOL_NAMES_SET } from '../../tool-configs/isml-tool-config.js';
+
+/**
+ * Handler for ISML documentation tools
+ */
+export class ISMLToolHandler extends SimpleClientHandler<ISMLToolName, ISMLClient> {
+  constructor(context: HandlerContext) {
+    super(context, 'ISML', {
+      toolConfig: ISML_TOOL_CONFIG,
+      toolNameSet: ISML_TOOL_NAMES_SET,
+      clientContextKey: 'ismlClient',
+      clientDisplayName: 'ISML',
+      createClient: () => new ISMLClient(),
+    });
+  }
+}