@solidstarters/solid-core 1.2.136 → 1.2.138

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.136",
+  "version": "1.2.138",
   "description": "This module is a NestJS module containing all the required core providers required by a Solid application",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/controllers/ai-interaction.controller.ts

@@ -96,6 +96,12 @@ export class AiInteractionController {
     return this.service.triggerMcpClientJob(dto.prompt);
   }
 
+  @ApiBearerAuth("jwt")
+  @Post(':id/apply-solid-ai-interaction')
+  async applySolidAiInteraction(@Param('id') id: number) {
+    return this.service.applySolidAiInteraction(+id);
+  }
+
   @ApiBearerAuth("jwt")
   @Post('/run-mcp-prompt')
   async runMcpPrompt(@Body() dto: InvokeAiPromptDto) {

package/src/dtos/create-dashboard-question.dto.ts

@@ -55,9 +55,8 @@ export class CreateDashboardQuestionDto {
     @IsString()
     @ApiProperty({ description: "This is the SQL query to fetch the KPI value for the question" })
     kpiSql: string;
-
-@IsOptional()
-@IsInt()
-@ApiProperty()
-sequenceNumber: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    sequenceNumber: number;
 }

package/src/dtos/create-dashboard.dto.ts

@@ -50,4 +50,12 @@ export class CreateDashboardDto {
     @IsOptional()
     @ApiProperty()
     moduleUserKey: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    displayName: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty({ description: "This is a description of the dashboard configuration, providing context and details about the dashboard." })
+    description: string;
 }

package/src/dtos/update-dashboard-question.dto.ts

@@ -60,9 +60,8 @@ export class UpdateDashboardQuestionDto {
     @IsString()
     @ApiProperty({ description: "This is the SQL query to fetch the KPI value for the question" })
     kpiSql: string;
-
-@IsOptional()
-@IsInt()
-@ApiProperty()
-sequenceNumber: number;
+    @IsOptional()
+    @IsInt()
+    @ApiProperty()
+    sequenceNumber: number;
 }

package/src/dtos/update-dashboard.dto.ts

@@ -54,4 +54,12 @@ export class UpdateDashboardDto {
     @IsOptional()
     @ApiProperty()
     moduleUserKey: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty()
+    displayName: string;
+    @IsOptional()
+    @IsString()
+    @ApiProperty({ description: "This is a description of the dashboard configuration, providing context and details about the dashboard." })
+    description: string;
 }

package/src/entities/dashboard-question.entity.ts

@@ -27,7 +27,6 @@ export class DashboardQuestion extends CommonEntity {
     labelSql: string;
     @Column({ type: "text", nullable: true })
     kpiSql: string;
-
-@Column({ type: "integer", nullable: true })
-sequenceNumber: number;
+    @Column({ type: "integer", nullable: true })
+    sequenceNumber: number;
 }

package/src/entities/dashboard.entity.ts

@@ -18,4 +18,8 @@ export class Dashboard extends CommonEntity {
     @ManyToOne(() => ModuleMetadata, { onDelete: "CASCADE", nullable: false })
     @JoinColumn()
     module: ModuleMetadata;
+    @Column({ type: "varchar", nullable: true })
+    displayName: string;
+    @Column({ type: "text", nullable: true })
+    description: string;
 }

package/src/helpers/module.helper.ts

@@ -3,23 +3,36 @@ import * as path from 'path'; // To handle file paths
 
 
 export const getDynamicModuleNames = (): string[] => {
-    const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
-  
-    // Adjust if 'src' is in a different location
-    const srcPath = path.join(process.cwd(), 'src');
-    const coreModuleNames = getCoreModuleNames();
-    const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
-  
-    const directories = fs.readdirSync(srcPath, { withFileTypes: true });
-    const enabledModules = directories
-      .filter(d => d.isDirectory() && !allExcludedModules.includes(d.name))
-      .map(d => d.name);
-  
-    console.log(`Enabled dynamic modules:`, enabledModules);
-    return enabledModules;
-  }
-  
-  export const getCoreModuleNames = (): string[] => {
-    // return ['iam', 'common', 'queues', 'app-builder'];
-    return ['solid-core'];
-  }
+  const dynamicModulesToExclude = process.env.SOLID_DYNAMIC_MODULES_TO_EXCLUDE?.split(',') || [];
+
+  // Adjust if 'src' is in a different location
+  const srcPath = path.join(process.cwd(), 'src');
+  const coreModuleNames = getCoreModuleNames();
+  const allExcludedModules = [...new Set([...coreModuleNames, ...dynamicModulesToExclude])];
+
+  const directories = fs.readdirSync(srcPath, { withFileTypes: true });
+  // const enabledModules = directories
+  //   .filter(d => d.isDirectory() && !allExcludedModules.includes(d.name))
+  //   .map(d => d.name);
+
+  const enabledModules = directories
+    .filter(dirent => {
+      const isValidDirectory = dirent.isDirectory() && !allExcludedModules.includes(dirent.name);
+
+      if (!isValidDirectory) return false;
+
+      const fullPath = path.join(srcPath, dirent.name);
+      const files = fs.readdirSync(fullPath);
+      // skip if empty directory
+      return files.length > 0;
+    })
+    .map(dirent => dirent.name);
+
+  console.log(`Enabled dynamic modules:`, enabledModules);
+  return enabledModules;
+}
+
+export const getCoreModuleNames = (): string[] => {
+  // return ['iam', 'common', 'queues', 'app-builder'];
+  return ['solid-core'];
+}

package/src/interfaces.ts

@@ -13,6 +13,7 @@ import { DashboardQuestion } from './entities/dashboard-question.entity';
 import { ComputedFieldMetadata } from './helpers/solid-registry';
 import { SqlExpression } from './services/question-data-providers/chartjs-sql-data-provider.service';
 import { CreateDashboardDto } from './dtos/create-dashboard.dto';
+import { AiInteraction } from './entities/ai-interaction.entity';
 
 export interface FieldCrudManager {
   // fieldMetadata: FieldMetadata;
@@ -77,6 +78,7 @@ export interface McpResponse {
   duration_ms?: number;
   errors?: string[];
   trace?: string[];
+  content_type?: string;
 }
 
 export interface ISelectionProviderContext {
@@ -101,6 +103,10 @@ export interface ISelectionProvider<T extends ISelectionProviderContext> {
 export interface IDashboardVariableSelectionProvider<T extends ISelectionProviderContext> extends ISelectionProvider<T> {
 }
 
+export interface IMcpToolResponseHandler {
+  apply(aiInteraction: AiInteraction);
+}
+
 export interface IDashboardQuestionDataProvider<TContext, TData> {
   help(): string;
 

package/src/jobs/database/trigger-mcp-client-subscriber-database.service.ts

@@ -34,36 +34,54 @@ export class TriggerMcpClientSubscriberDatabase extends DatabaseSubscriber<Trigg
         const aiInteraction = await this.aiInteractionService.findOne(codeGnerationOptions.aiInteractionId, {
             populate: ['user']
         });
+        if (!aiInteraction) {
+            const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${codeGnerationOptions.aiInteractionId}`
+            this.triggerMcpClientSubscriberLogger.log(m);
+            throw new Error(m);
+        }
 
         // The message contains the users prompt.
         const prompt = aiInteraction.message;
 
         // Use this to invoke our mcp client
         const aiResponse = await this.aiInteractionService.runMcpPrompt(prompt);
-        let nestedResponse = aiResponse.response.trim();
+        this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
+        this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));
+
         if (!aiResponse.success) {
-            // update the job entry with success... raising an error will lead the job to be marked as failed...
-            throw new Error(aiResponse.errors.join(','));
+            this.triggerMcpClientSubscriberLogger.log(`Gen ai has returned with a false status code`);
+
+            const errorsStr = aiResponse.errors.join('; ');
+
+            await this.aiInteractionService.create({
+                userId: aiInteraction.user.id,
+                threadId: aiInteraction.threadId,
+                role: 'gen-ai',
+                message: '-',
+                contentType: aiResponse.content_type,
+                errorMessage: errorsStr,
+                modelUsed: aiResponse.model,
+                responseTimeMs: aiResponse.duration_ms,
+                metadata: JSON.stringify(aiResponse)
+            });
+
+            // update the job entry with failure... raising an error will lead the job to be marked as failed...
+            throw new Error(errorsStr);
         }
         else {
-            // TODO: create a new entry not update...
-            // const updatedDto = {
-            //     ...aiInteraction,
-            //     message: nestedResponse,
-            // }
-            // await this.aiInteractionService.update(codeGnerationOptions.aiInteractionId, updatedDto);
+            let nestedResponse = aiResponse.response.trim();
 
             await this.aiInteractionService.create({
                 userId: aiInteraction.user.id,
                 threadId: aiInteraction.threadId,
                 role: 'gen-ai',
                 message: nestedResponse,
-                contentType: '',
+                contentType: aiResponse.content_type,
                 errorMessage: '',
                 modelUsed: aiResponse.model,
                 responseTimeMs: aiResponse.duration_ms,
                 metadata: JSON.stringify(aiResponse)
-            })
+            });
         }
 
         return aiResponse;

package/src/seeders/seed-data/solid-core-metadata.json

@@ -4308,6 +4308,33 @@
             "isSystem": true,
             "isUserKey": true
           },
+          {
+            "name": "displayName",
+            "displayName": "Display Name",
+            "type": "shortText",
+            "ormType": "varchar",
+            "length": 256,
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "isUserKey": false
+          },
+          {
+            "name": "description",
+            "displayName": "Description",
+            "type": "longText",
+            "ormType": "text",
+            "required": false,
+            "unique": false,
+            "index": false,
+            "private": false,
+            "encrypt": false,
+            "isSystem": true,
+            "description": "This is a description of the dashboard configuration, providing context and details about the dashboard."
+          },
           {
             "name": "layoutJson",
             "displayName": "Layout Json",
@@ -11075,6 +11102,12 @@
               "name": "name"
             }
           },
+          {
+            "type": "field",
+            "attrs": {
+              "name": "displayName"
+            }
+          },
           {
             "type": "field",
             "attrs": {
@@ -11138,6 +11171,18 @@
                                   "name": "name"
                                 }
                               },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "displayName"
+                                }
+                              },
+                              {
+                                "type": "field",
+                                "attrs": {
+                                  "name": "description"
+                                }
+                              },
                               {
                                 "type": "field",
                                 "attrs": {

package/src/services/ai-interaction.service.ts

@@ -16,6 +16,7 @@ import { McpResponse, TriggerMcpClientOptions } from 'src/interfaces';
 import { PublisherFactory } from './queues/publisher-factory.service';
 import { RequestContextService } from './request-context.service';
 import { ActiveUserData } from 'src/interfaces/active-user-data.interface';
+import { McpToolResponseHandlerFactory } from './mcp-tool-response-handlers/mcp-tool-response-handler-factory.service';
 
 @Injectable()
 export class AiInteractionService extends CRUDService<AiInteraction> {
@@ -35,6 +36,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     readonly moduleRef: ModuleRef,
     readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
     readonly requestContextService: RequestContextService,
+    readonly mcpToolResponseHandlerFactory: McpToolResponseHandlerFactory,
 
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
@@ -101,9 +103,9 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     // TODO: Refactor to use the command.service.ts instead...
     return new Promise((resolve, reject) => {
       this.logger.log(`Attempting to run command:`)
-      this.logger.log(`${pythonExecutable} ${mcpClient} ${prompt}`);
+      this.logger.log(`${pythonExecutable} ${mcpClient} "${prompt}"`);
 
-      const python = spawn(pythonExecutable, [mcpClient, prompt]);
+      const python = spawn(pythonExecutable, [mcpClient, `"${prompt}"`]);
 
       let stdout = '';
       let stderr = '';
@@ -160,4 +162,50 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     return response;
   }
 
+  async applySolidAiInteraction(id: number) {
+    // Fetch the aiInteraction
+    const aiInteraction = await this.findOne(id, {
+      populate: ['user']
+    });
+    if (!aiInteraction) {
+      const m = `Unable to identified the aiInteraction entry that triggered this job... using id: ${id}`
+
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(m);
+    }
+
+    // TODO: Validation: Check if JSON.parse(metadata).tools_invoked starts with solid_
+    let metadata = {};
+    try {
+      metadata = JSON.parse(aiInteraction.metadata);
+    }
+    catch (e) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error(e);
+    }
+
+    const toolsInvoked = metadata['tools_invoked'];
+    if (!toolsInvoked) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error('Unable to resolve a solid_ command that was used to come up with this response.');
+    }
+
+    // TODO: OPTIMISATION for chained tool invocation, for now we are assuming only 1 tool was used.
+    const toolInvoked = toolsInvoked[0];
+
+    // TODO: use the toolInvoked to identify a service using some convention.
+    // TODO: Eg. if toolInvoked is solid_create_module <> SolidCreateModuleMcpToolHandler ... create a factory class to do this mapping and identify the relevant provider. 
+    const mcpToolHandler = this.mcpToolResponseHandlerFactory.getInstance(toolInvoked);
+    if (!mcpToolHandler) {
+      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
+      throw new Error('Unable to resolve a mcp tool handler.');
+    }
+
+    const handlerApplicationResponse = await mcpToolHandler.apply(aiInteraction);
+
+    // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
+    // throw new Error('Method not implemented.');
+
+    return handlerApplicationResponse;
+  }
 }

package/src/services/dashboard.service.ts

@@ -129,10 +129,15 @@ export class DashboardService extends CRUDService<Dashboard> {
   }
 
   private async writeToConfig(metaData: any, dashboard: Dashboard, filePath: string) {
-    if (metaData.dashboards) {
+    if (metaData.dashboards && Array.isArray(metaData.dashboards)) {
       const dashboardIndex = metaData.dashboards?.findIndex((dashboardFromFile: { name: string; }) => dashboardFromFile.name === dashboard.name);
       const dto = await this.dashboardMapper.toDto(dashboard);
-      metaData.dashboards[dashboardIndex] = dto;
+      if (dashboardIndex !== -1) {
+        metaData.dashboards[dashboardIndex] = dto;
+      }
+      else {
+        metaData.dashboards.push(dto);
+      }
     }
     else {
       const dashboards = [];

package/src/services/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service.ts

@@ -0,0 +1,36 @@
+import { Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
+
+import { QueueMessage, QueuePublisher } from 'src/interfaces/mq';
+import { classify } from '@angular-devkit/core/src/utils/strings';
+import { SolidIntrospectService } from '../solid-introspect.service';
+import { IMcpToolResponseHandler } from 'src/interfaces';
+
+
+@Injectable()
+export class McpToolResponseHandlerFactory {
+    private readonly logger = new Logger(McpToolResponseHandlerFactory.name);
+
+    constructor(
+        private readonly solidIntrospectionService: SolidIntrospectService
+    ) {
+    }
+
+    getInstance(toolInvoked: string): IMcpToolResponseHandler {
+        toolInvoked = classify(toolInvoked);
+
+        let resolvedHandlerName = `${toolInvoked}McpToolResponseHandler`;
+
+        // Register all ISolidDatabaseModules implementations
+        let actualHandler = this.solidIntrospectionService.getProvider(resolvedHandlerName);
+        if (!actualHandler) {
+            throw new Error(`Unable to locate mcp tool handler with name ${resolvedHandlerName}`);
+        }
+
+        // type safe
+        const actualHandlerInstance: IMcpToolResponseHandler = actualHandler.instance;
+        this.logger.error(`Resolved mcp tool response handler with name ${actualHandler.name}`);
+
+        return actualHandlerInstance;
+    }
+}

package/src/services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from "@nestjs/common";
+import { IMcpToolResponseHandler } from "../../interfaces";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { ModuleMetadataService } from "../module-metadata.service";
+import { CreateModuleMetadataDto } from "src/dtos/create-module-metadata.dto";
+import { SolidRegistry } from "src/helpers/solid-registry";
+
+@Injectable()
+export class SolidCreateModuleMcpToolResponseHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly moduleMetadataService: ModuleMetadataService,
+        private readonly solidRegistry: SolidRegistry,
+
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        const aiResponse = JSON.parse(aiInteraction.message);
+
+        const moduleMetadata = aiResponse['moduleMetadata'];
+
+        // TODO: Validate if another module with same name exists, if it does then raise an error...
+
+        const createDto: CreateModuleMetadataDto = {
+            defaultDataSource: 'default',
+            description: moduleMetadata['description'],
+            displayName: moduleMetadata['displayName'],
+            isSystem: false,
+            menuIconUrl: '',
+            models: [],
+            name: moduleMetadata['name'],
+            menuSequenceNumber: 1
+        }
+
+        // This creates the module-metadata.json file....
+        const moduleObj = await this.moduleMetadataService.create(createDto);
+
+        // const seeder = this.solidRegistry.getSeeders().filter((seeder) => seeder.name === 'ModuleMetadataSeederService').map((seeder) => seeder.instance).pop();
+
+        // Now we need to run solid seed & then solid refresh-model --name <module-name>
+        await this.moduleMetadataService.generateCode({ moduleId: moduleObj.id });
+
+        // solid seed ... this has to be run after reboot from the UI...
+        // await new Promise(resolve => setTimeout(resolve, 1000));
+        // await seeder.seed();
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: true,
+            serverRebooting: true,
+        }
+    }
+
+}

package/src/services/module-metadata.service.ts

@@ -213,7 +213,6 @@ export class ModuleMetadataService {
     }
   }
 
-
   async updateInDB(manager: EntityManager, id: number, updateModuleMetadataDto: UpdateModuleMetadataDto, files: Express.Multer.File[] = []) {
 
     const module = await this.moduleMetadataRepo.preload({
@@ -286,7 +285,6 @@ export class ModuleMetadataService {
     }
   }
 
-
   async upsert(updateModuleMetadataDto: UpdateModuleMetadataDto) {
     this.logger.log(`Module Upsert called for : ${updateModuleMetadataDto.name}`);
     // First check if module already exists using name
@@ -308,9 +306,6 @@ export class ModuleMetadataService {
     }
   }
 
-
-
-
   async removeByName(name: string) {
     const entity = await this.findOneByUserKey(name);
     if (entity) {

package/src/services/scheduled-jobs/scheduled-job.interface.ts

@@ -1,5 +1,5 @@
 import { ScheduledJob } from "src/entities/scheduled-job.entity";
 
 export interface IScheduledJob {
-    executeReminder(reminder: ScheduledJob): Promise<void>;
+    execute(job: ScheduledJob): Promise<void>;
 }

package/src/services/scheduled-jobs/scheduler.service.ts

@@ -22,7 +22,7 @@ export class SchedulerServiceImpl implements ISchedulerService {
     async runScheduledJobs(): Promise<void> {
         const now = new Date();
 
-        this.logger.log(`[${now.getTime()}]: scheduler service started run...`);
+        // this.logger.log(`[${now.getTime()}]: scheduler service started run...`);
         const dueJobs = await this.scheduledJobRepo.find({
             where: [
                 {
@@ -37,7 +37,7 @@ export class SchedulerServiceImpl implements ISchedulerService {
             ],
         });
 
-        this.logger.log(`[${now.getTime()}]: scheduler service identified ${dueJobs.length} jobs to run...`);
+        // this.logger.log(`[${now.getTime()}]: scheduler service identified ${dueJobs.length} jobs to run...`);
 
         for (const job of dueJobs) {
             this.logger.log(`[${now.getTime()}]: scheduler service attempting to run job ${job.job}`);
@@ -49,13 +49,13 @@ export class SchedulerServiceImpl implements ISchedulerService {
 
                 const handler = this.solidRegistry.getScheduledJobProviderInstance(job.job);
                 if (!handler) {
-                    this.logger.warn(`[${now.getTime()}]: scheduler service skipping because job handler not found: ${job.job}`);
+                    // this.logger.warn(`[${now.getTime()}]: scheduler service skipping because job handler not found: ${job.job}`);
                     continue;
                 }
 
-                this.logger.log(`[${now.getTime()}]: scheduler service about to run job ${job.job}`);
-                await handler.executeReminder(job);
-                this.logger.log(`[${now.getTime()}]: scheduler service finished running job ${job.job}`);
+                // this.logger.log(`[${now.getTime()}]: scheduler service about to run job ${job.job}`);
+                await handler.execute(job);
+                // this.logger.log(`[${now.getTime()}]: scheduler service finished running job ${job.job}`);
 
                 job.isActive = true;
                 job.lastRunAt = now;

package/src/services/sql-expression-resolver.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from "@nestjs/common";
 import { SqlExpression, SqlExpressionOperator } from "./question-data-providers/chartjs-sql-data-provider.service";
+import { RequestContextService } from "./request-context.service";
 
 export interface SqlReplacementResult {
   rawSql: string;
@@ -8,10 +9,25 @@ export interface SqlReplacementResult {
 
 @Injectable()
 export class SqlExpressionResolverService {
+  constructor(private readonly requestContextService: RequestContextService) { }
   resolveSqlWithExpressions(sql: string, expressions: SqlExpression[]): SqlReplacementResult {
     const variableToColumnMap: Record<string, string> = {};
     const variablePattern = /{{\s*(\w+)\s*\[\s*([\w.]+)\s*\]\s*}}/g;
 
+    let paramIndex = 1;
+    const parameters: any[] = [];
+
+    // Handle sql expression tokens like {{$activeUserId}} in the SQL string
+    if (sql.includes('{{$activeUserId}}')) {
+      const activeUser = this.requestContextService.getActiveUser();
+      if (activeUser && activeUser.sub) {
+        // Replace custom placeholder with parameter placeholder ($1)
+        sql = sql.replace(/\{\{\$activeUserId\}\}/g, `$${paramIndex++}`);
+        // Add the active user ID to parameters
+        parameters.push(activeUser.sub);
+      }
+    }
+
     // --- Pass 1: extract variable -> column mappings ---
     let simplifiedSql = sql.replace(variablePattern, (_, variableName, columnName) => {
       variableToColumnMap[variableName] = columnName;
@@ -19,8 +35,6 @@ export class SqlExpressionResolverService {
     });
 
     // --- Pass 2: Replace each variable with positional fragment ---
-    let paramIndex = 1;
-    const parameters: any[] = [];
 
     for (const expr of expressions) {
       const column = variableToColumnMap[expr.variableName];

package/src/solid-core.module.ts

@@ -247,6 +247,8 @@ import { DashboardSubscriber } from './subscribers/dashboard.subscriber';
 import { SecurityRuleSubscriber } from './subscribers/security-rule.subscriber';
 import { ViewMetadataSubsciber } from './subscribers/view-metadata.subscriber';
 import { CRUDService } from './services/crud.service';
+import { McpToolResponseHandlerFactory } from './services/mcp-tool-response-handlers/mcp-tool-response-handler-factory.service';
+import { SolidCreateModuleMcpToolResponseHandler } from './services/mcp-tool-response-handlers/solid-create-module-mcp-tool-response-handler.service';
 
 
 @Global()
@@ -417,6 +419,9 @@ import { CRUDService } from './services/crud.service';
     SmsTemplateService,
     EmailTemplateService,
     PublisherFactory,
+    
+    McpToolResponseHandlerFactory,
+    SolidCreateModuleMcpToolResponseHandler,
 
     TriggerMcpClientPublisherDatabase,
     TriggerMcpClientSubscriberDatabase,