@solidstarters/solid-core 1.2.180 → 1.2.183

package/src/seeders/permission-metadata-seeder.service.ts

@@ -25,7 +25,7 @@ export class PermissionMetadataSeederService {
     for (let id = 0; id < controllers.length; id++) {
       try {
         const controller = controllers[id];
-        this.logger.log(`Resolving controller: ${controller.name}`);
+        // this.logger.log(`Resolving controller: ${controller.name}`);
 
         const methods = controller.methods;
         for (let mId = 0; mId < methods.length; mId++) {

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

@@ -12136,6 +12136,7 @@
       "modelUserKey": "aiInteraction",
       "layout": {
         "type": "form",
+        "edit": false,
         "attrs": {
           "name": "form-1",
           "label": "AI Interaction",
@@ -12203,8 +12204,7 @@
                                 "type": "field",
                                 "attrs": {
                                   "name": "message",
-                                  "editWidget": "textarea",
-                                  "rows": 6
+                                  "viewWidget": "SolidAiInteractionMessageFieldFormWidget"
                                 }
                               }
                             ]
@@ -12296,7 +12296,6 @@
                                 "type": "field",
                                 "attrs": {
                                   "name": "errorMessage",
-                                  "editWidget": "textarea",
                                   "rows": 5
                                 }
                               }
@@ -12332,8 +12331,7 @@
                                 "attrs": {
                                   "name": "metadata",
                                   "height": "80vh",
-                                  "viewWidget":"SolidAiInteractionMetadataFieldFormWidget"
-
+                                  "viewWidget": "SolidAiInteractionMetadataFieldFormWidget"
                                 }
                               }
                             ]

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

@@ -14,11 +14,9 @@ import { AiInteraction } from '../entities/ai-interaction.entity';
 import * as fs from 'fs/promises';
 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';
 import { ERROR_MESSAGES } from 'src/constants/error-messages';
 import { InvokeAiPromptDto } from 'src/dtos/invoke-ai-prompt.dto';
+import { McpHandlerFactory } from './genai/mcp-handlers/mcp-handler-factory.service';
 
 @Injectable()
 export class AiInteractionService extends CRUDService<AiInteraction> {
@@ -38,7 +36,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
     readonly moduleRef: ModuleRef,
     readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
     // readonly requestContextService: RequestContextService,
-    readonly mcpToolResponseHandlerFactory: McpToolResponseHandlerFactory,
+    readonly mcpHandlerFactory: McpHandlerFactory,
 
   ) {
     super(modelMetadataService, moduleMetadataService, configService, fileService, discoveryService, crudHelperService, entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
@@ -230,7 +228,7 @@ export class AiInteractionService extends CRUDService<AiInteraction> {
 
     // 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);
+    const mcpToolHandler = this.mcpHandlerFactory.getInstance(toolInvoked);
     if (!mcpToolHandler) {
       // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
       throw new Error(ERROR_MESSAGES.UNABLE_TO_RESOLVE_MCP_HANDLER);

package/src/services/genai/ingest-metadata.service.ts

@@ -123,6 +123,20 @@ export class IngestMetadataService {
             // Delete and re-insert a document representing the full json...
             // await this.deleteInsertRagDocumentForModuleMetadataJsonFile(ingestionInfo, fullPath, fileName)
 
+            // Delete all metadata chunks. 
+            // const collectionName = `${enabledModule}-rag-collection`;
+            // const deleteResult = await this.ragClient.documents.deleteByFilter({
+            //     filters: {
+            //         // AND semantics across fields:
+            //         "$and": [
+            //             { 'metadata.kind': { $eq: 'solidx-metadata' } },
+            //             { 'metadata.collectionName': { $eq: collectionName } },
+            //             { 'title': { $like: '%Ingested Chunks%' } },
+            //         ]
+            //     },
+            // });
+            // this.logger.log(`Deleted existing documents for collectionName: ${collectionName}. Got response:`, deleteResult);
+
             // Delete and re-insert a chunk representing the module.
             await this.deleteInsertRagChunkForModule(ingestionInfo, moduleMetadata);
 
@@ -160,37 +174,52 @@ export class IngestMetadataService {
     private async resolveRagCollectionForModule(ingestionInfo: ModuleRAGIngestionInfo, moduleName: string): Promise<string> {
         this.logger.debug(`Resolving RAG collection for module: ${moduleName}`);
 
-        let existingCollection: CollectionResponse = null;
-        if (ingestionInfo.collectionId) {
-            // See if collection already exists... 
-            const r = await this.ragClient.collections.list({
-                ids: [
-                    ingestionInfo.collectionId
-                ]
-            });
-
-            if (r) {
-                if (r.results.length === 1) {
-                    existingCollection = r.results[0];
-                }
-                if (r.results.length > 1) {
-                    // TODO: do something that will print a meaningful error on the console...
-                }
-            }
-        }
-
-        if (!existingCollection) {
-            const r = await this.ragClient.collections.create({
-                name: `${moduleName}-rag-collection`,
-                description: `Collection created to group all documents, chunks related to module: ${moduleName}`
-            });
+        const collectionName = `${moduleName}-rag-collection`;
 
-            // TODO: for some reason if we are unable to create a collection then fail with a visible error message in the console...
+        // delete and recreate 
+        // if (alwaysRecreate === true) {
+        const existingCollection = await this.ragClient.collections.retrieveByName({
+            name: collectionName
+        });
 
-            return r.results.id;
+        if (existingCollection) {
+            try {
+                await this.ragClient.collections.delete({ id: existingCollection.results.id });
+            } catch (e) {
+                this.logger.warn(`[Warn] Failed deleteByFilter for collection': ${String(e)}`);
+            }
         }
+        // }
+
+        // let existingCollection: CollectionResponse = null;
+        // if (ingestionInfo.collectionId) {
+        //     // See if collection already exists... 
+        //     const r = await this.ragClient.collections.list({
+        //         ids: [
+        //             ingestionInfo.collectionId
+        //         ]
+        //     });
+
+        //     if (r) {
+        //         if (r.results.length === 1) {
+        //             existingCollection = r.results[0];
+        //         }
+        //         if (r.results.length > 1) {
+        //             // TODO: do something that will print a meaningful error on the console...
+        //         }
+        //     }
+        // }
+
+        // if (!existingCollection) {
+        const r = await this.ragClient.collections.create({
+            name: collectionName,
+            description: `Collection created to group all documents, chunks related to module: ${moduleName}`
+        });
 
-        return existingCollection.id;
+        // TODO: for some reason if we are unable to create a collection then fail with a visible error message in the console...
+        return r.results.id;
+        // }
+        // return existingCollection.id;
     }
 
     private async deleteInsertRagDocumentForModuleMetadataJsonFile(ingestionInfo: ModuleRAGIngestionInfo, fullPath: string, fileName: string): Promise<void> {
@@ -298,12 +327,35 @@ Usage: Use this chunk to choose the correct model/field chunks for code generati
         };
 
         // Delete previous chunk if we have one
-        if (ingestionInfo.moduleChunkId) {
-            try {
-                await this.ragClient.documents.delete({ id: ingestionInfo.moduleChunkId });
-            } catch (e) {
-                this.logger.warn(`[Warn] Failed deleting old module chunk (${ingestionInfo.moduleChunkId}): ${String(e)}`);
-            }
+        // if (ingestionInfo.moduleChunkId) {
+        //     try {
+        //         await this.ragClient.documents.delete({ id: ingestionInfo.moduleChunkId });
+        //     } catch (e) {
+        //         this.logger.warn(`[Warn] Failed deleting old module chunk (${ingestionInfo.moduleChunkId}): ${String(e)}`);
+        //     }
+        // }
+
+        // We changed the approach to delete and re-create using metadata.
+        // delete any existing module records by metadata (idempotent)
+        try {
+            const deleteResult = await this.ragClient.documents.deleteByFilter({
+                filters: {
+                    // AND semantics across fields:
+                    "$and": [
+                        { 'metadata.kind': { $eq: 'solidx-metadata' } },
+                        { 'metadata.type': { $eq: 'module' } },
+                        { 'metadata.moduleName': { $eq: moduleName } },
+                        // (optional but nice to constrain tightly if you always set it)
+                        { 'metadata.collectionName': { $eq: `${moduleName}-rag-collection` } },
+                    ]
+                },
+            });
+
+            this.logger.log(`Deleted existing module document for moduleName: ${moduleName}. Got response:`, deleteResult);
+
+        } catch (e) {
+            this.logger.warn(`[Warn] Failed deleteByFilter for module '${moduleName}': ${String(e)}`);
+            // Non-fatal: we can still proceed to create; caller’s auth will limit scope anyway
         }
 
         const r = await this.ragClient.documents.create({
@@ -407,12 +459,36 @@ ${JSON.stringify(model)}
         };
 
         // 5) Delete previous chunk if present
-        if (modelEntry.modelChunkId) {
-            try {
-                await this.ragClient.documents.delete({ id: modelEntry.modelChunkId });
-            } catch (e) {
-                this.logger.warn(`[Warn] Failed deleting old model chunk (${modelEntry.modelChunkId}): ${String(e)}`);
-            }
+        // if (modelEntry.modelChunkId) {
+        //     try {
+        //         await this.ragClient.documents.delete({ id: modelEntry.modelChunkId });
+        //     } catch (e) {
+        //         this.logger.warn(`[Warn] Failed deleting old model chunk (${modelEntry.modelChunkId}): ${String(e)}`);
+        //     }
+        // }
+
+        // We changed the approach to delete and re-create using metadata.
+        // delete any existing module records by metadata (idempotent)
+        try {
+            const deleteResult = await this.ragClient.documents.deleteByFilter({
+                filters: {
+                    // AND semantics across fields:
+                    "$and": [
+                        { 'metadata.kind': { $eq: 'solidx-metadata' } },
+                        { 'metadata.type': { $eq: 'model' } },
+                        { 'metadata.moduleName': { $eq: moduleName } },
+                        { 'metadata.modelName': { $eq: modelName } },
+                        // (optional but nice to constrain tightly if you always set it)
+                        { 'metadata.collectionName': { $eq: `${moduleName}-rag-collection` } },
+                    ]
+                },
+            });
+
+            this.logger.log(`Deleted existing model document for modelName: ${modelName}. Got response:`, deleteResult);
+
+        } catch (e) {
+            this.logger.warn(`[Warn] Failed deleteByFilter for module '${moduleName}': ${String(e)}`);
+            // Non-fatal: we can still proceed to create; caller’s auth will limit scope anyway
         }
 
         // 6) Create new document (R2R auto-generates the ID)

package/src/services/{mcp-tool-response-handlers/mcp-tool-response-handler-factory.service.ts → genai/mcp-handlers/mcp-handler-factory.service.ts}

@@ -2,12 +2,12 @@ import { Injectable, Logger } from '@nestjs/common';
 
 import { classify } from '@angular-devkit/core/src/utils/strings';
 import { IMcpToolResponseHandler } from 'src/interfaces';
-import { SolidIntrospectService } from '../solid-introspect.service';
+import { SolidIntrospectService } from '../../solid-introspect.service';
 
 
 @Injectable()
-export class McpToolResponseHandlerFactory {
-    private readonly logger = new Logger(McpToolResponseHandlerFactory.name);
+export class McpHandlerFactory {
+    private readonly logger = new Logger(McpHandlerFactory.name);
 
     constructor(
         private readonly solidIntrospectionService: SolidIntrospectService
@@ -17,9 +17,9 @@ export class McpToolResponseHandlerFactory {
     getInstance(toolInvoked: string): IMcpToolResponseHandler {
         toolInvoked = classify(toolInvoked);
 
-        let resolvedHandlerName = `${toolInvoked}McpToolResponseHandler`;
+        let resolvedHandlerName = `${toolInvoked}McpHandler`;
 
-        // Register all ISolidDatabaseModules implementations
+        // Get hold of the tool response handler instance using the tool name used. 
         let actualHandler = this.solidIntrospectionService.getProvider(resolvedHandlerName);
         if (!actualHandler) {
             throw new Error(`Unable to locate mcp tool handler with name ${resolvedHandlerName}`);

package/src/services/genai/mcp-handlers/solid-add-fields-to-model-mcp-handler.service.ts

@@ -0,0 +1,68 @@
+import { Injectable } from "@nestjs/common";
+import { UpdateModelMetaDataDto } from "src/dtos/update-model-metadata.dto";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { FieldMetadata } from "src/entities/field-metadata.entity";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+import { ModelMetadataService } from "../../model-metadata.service";
+
+@Injectable()
+// solid_add_field
+export class SolidAddFieldsToModelMcpHandler implements IMcpToolResponseHandler {
+
+    constructor(
+        private readonly modelMetadataService: ModelMetadataService,
+    ) {
+    }
+
+    async apply(aiInteraction: AiInteraction) {
+        // const aiResponse = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
+
+        // {
+        //   "generation_status": "success",
+        //   "instructions": "<optional string>",
+        //   "data": {
+        //     "modelUserKey": "<existing model name>",
+        //     "schemaPatch": {
+        //       "fieldsToAdd": [
+        //         <json representing each of the fields to be added>
+        //       ]
+        //     }
+        //   }
+        // }        
+        // const { modelUserKey, fieldSchema } = aiResponseMessage;
+        const { data } = aiResponseMessage;
+        const { modelUserKey, schemaPatch } = data;
+        const { fieldsToAdd } = schemaPatch;
+
+        // TODO: Validate if another field with same name exists, if it does then raise an error...
+
+        // TODO: load the model with the fields.
+        const modelMetadata = await this.modelMetadataService.findOneByUserKey(modelUserKey, ['fields']);
+        if (!modelMetadata) {
+            throw new Error(`Model with user key ${modelUserKey} not found.`);
+        }
+
+        for (let i = 0; i < fieldsToAdd.length; i++) {
+            const fieldSchema = fieldsToAdd[i];
+
+            // Add the fieldSchema to the model fields array
+            fieldSchema['modelId'] = modelMetadata.id;
+            modelMetadata.fields.push(fieldSchema as FieldMetadata);
+        }
+
+        // This adds the field to the respective model metadat...
+        await this.modelMetadataService.update(modelMetadata.id, modelMetadata as unknown as UpdateModelMetaDataDto);
+
+        // Now we need to run solid seed & then solid refresh-model --name <module-name>
+        await this.modelMetadataService.handleGenerateCode({ modelId: modelMetadata.id });
+
+        // TODO: decide on some shape to return hre...
+        return {
+            seedingRequired: true,
+            serverRebooting: true,
+        }
+    }
+
+}

package/src/services/genai/mcp-handlers/solid-create-computed-provider-mcp-handler.service.ts

@@ -0,0 +1,71 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { AiInteraction } from "src/entities/ai-interaction.entity";
+import { IMcpToolResponseHandler, McpComputedProviderResponse, PlanStep } from "../../../interfaces";
+import { SolidTsMorphService } from "src/services/solid-ts-morph.service";
+
+const RESTART_TOUCH_FILE = process.env.MCP_RESTART_TOUCH_FILE || "tmp/restart.touch";
+
+@Injectable()
+export class SolidCreateComputedProviderMcpHandler implements IMcpToolResponseHandler {
+  private readonly logger = new Logger(SolidCreateComputedProviderMcpHandler.name);
+
+  constructor(private readonly tsMorph: SolidTsMorphService) { }
+
+  async apply(aiInteraction: AiInteraction) {
+    const raw = this.safeParse(aiInteraction.message);
+    const payload: McpComputedProviderResponse | undefined = (raw?.data?.plan ? raw.data : raw) as McpComputedProviderResponse;
+
+    if (!payload || !Array.isArray(payload.plan)) {
+      throw new Error("SolidCreateComputedProviderMcpHandler: invalid MCP response; missing plan[]");
+    }
+
+    // Batch all plan steps in a single txn so nodemon restarts only once.
+    this.tsMorph.begin();
+    try {
+      for (const step of payload.plan as PlanStep[]) {
+        switch (step.type) {
+          case "createNewFile": {
+            const overwrite = step.overwrite ?? false;
+            this.tsMorph.createNewFile(step.path, step.content, overwrite);
+            break;
+          }
+          case "registerNestProvider": {
+            const uniqueGuard = step.uniqueGuard ?? true;
+            this.tsMorph.registerNestProvider(
+              step.modulePath,
+              step.providerClassName,
+              step.importFrom,
+              step.registerIn,
+              uniqueGuard,
+            );
+            break;
+          }
+          default:
+            throw new Error(`Unsupported plan step type: ${(step as any).type}`);
+        }
+      }
+
+      const result = await this.tsMorph.commit();
+
+      return {
+        seedingRequired: false,
+        serverRebooting: false,
+        appliedSteps: payload.plan.length,
+        wroteFiles: result.wrote,
+      };
+    } catch (err) {
+      this.logger.error(`Apply failed; rolling back. ${String(err)}`);
+      this.tsMorph.rollback();
+      throw err;
+    }
+  }
+
+  private safeParse(str: string): any {
+    try {
+      return JSON.parse(str);
+    } catch {
+      const unescaped = str.replace(/\\'/g, "'");
+      return JSON.parse(unescaped);
+    }
+  }
+}

package/src/services/{mcp-tool-response-handlers/solid-create-dashboard-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-create-dashboard-mcp-handler.service.ts}

@@ -4,16 +4,16 @@ import { CreateDashboardDto } from "src/dtos/create-dashboard.dto";
 import { UpdateMenuItemMetadataDto } from "src/dtos/update-menu-item-metadata.dto";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
 import { Dashboard } from "src/entities/dashboard.entity";
-import { IMcpToolResponseHandler } from "../../interfaces";
-import { ActionMetadataService } from "../action-metadata.service";
-import { DashboardService } from "../dashboard.service";
-import { MenuItemMetadataService } from "../menu-item-metadata.service";
-import { ModelMetadataService } from "../model-metadata.service";
-import { ModuleMetadataService } from "../module-metadata.service";
-import { RoleMetadataService } from "../role-metadata.service";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+import { ActionMetadataService } from "../../action-metadata.service";
+import { DashboardService } from "../../dashboard.service";
+import { MenuItemMetadataService } from "../../menu-item-metadata.service";
+import { ModelMetadataService } from "../../model-metadata.service";
+import { ModuleMetadataService } from "../../module-metadata.service";
+import { RoleMetadataService } from "../../role-metadata.service";
 
 @Injectable()
-export class SolidCreateDashboardMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidCreateDashboardMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardService: DashboardService,

package/src/services/{mcp-tool-response-handlers/solid-create-dashboard-question-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-create-dashboard-question-mcp-handler.service.ts}

@@ -2,11 +2,11 @@ import { Injectable } from "@nestjs/common";
 import { plainToInstance } from "class-transformer";
 import { CreateDashboardQuestionDto } from "src/dtos/create-dashboard-question.dto";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler } from "../../interfaces";
-import { DashboardQuestionService } from "../dashboard-question.service";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+import { DashboardQuestionService } from "../../dashboard-question.service";
 
 @Injectable()
-export class SolidCreateDashboardQuestionMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidCreateDashboardQuestionMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardQuestionService: DashboardQuestionService,

package/src/services/{mcp-tool-response-handlers/solid-create-dashboard-question-sql-dataset-config-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-create-dashboard-question-sql-dataset-config-mcp-handler.service.ts}

@@ -1,12 +1,12 @@
 import { Injectable } from "@nestjs/common";
 import { plainToInstance } from "class-transformer";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler } from "../../interfaces";
-import { DashboardQuestionSqlDatasetConfigService } from "../dashboard-question-sql-dataset-config.service";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+import { DashboardQuestionSqlDatasetConfigService } from "../../dashboard-question-sql-dataset-config.service";
 import { CreateDashboardQuestionSqlDatasetConfigDto } from "src/dtos/create-dashboard-question-sql-dataset-config.dto";
 
 @Injectable()
-export class SolidCreateDashboardQuestionSqlDatasetConfigMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidCreateDashboardQuestionSqlDatasetConfigMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardQuestionSqlDatasetConfigService: DashboardQuestionSqlDatasetConfigService,

package/src/services/{mcp-tool-response-handlers/solid-create-dashboard-widget-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-create-dashboard-widget-mcp-handler.service.ts}

@@ -2,11 +2,11 @@ import { Injectable } from "@nestjs/common";
 import { plainToInstance } from "class-transformer";
 import { CreateDashboardQuestionDto } from "src/dtos/create-dashboard-question.dto";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { IMcpToolResponseHandler } from "../../interfaces";
-import { DashboardQuestionService } from "../dashboard-question.service";
+import { IMcpToolResponseHandler } from "../../../interfaces";
+import { DashboardQuestionService } from "../../dashboard-question.service";
 
 @Injectable()
-export class SolidCreateDashboardWidgetMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidCreateDashboardWidgetMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly dashboardQuestionService: DashboardQuestionService,

package/src/services/{mcp-tool-response-handlers/solid-create-model-with-fields-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-create-model-with-fields-mcp-handler.service.ts}

@@ -1,19 +1,16 @@
 import { Injectable } from "@nestjs/common";
-import { IMcpToolResponseHandler } from "../../interfaces";
+import { IMcpToolResponseHandler } from "../../../interfaces";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { SolidRegistry } from "src/helpers/solid-registry";
-import { ModelMetadataService } from "../model-metadata.service";
+import { ModelMetadataService } from "../../model-metadata.service";
 import { CreateModelMetadataDto } from "src/dtos/create-model-metadata.dto";
-import { ModuleMetadataService } from "../module-metadata.service";
-import { model } from "mongoose";
+import { ModuleMetadataService } from "../../module-metadata.service";
 
 @Injectable()
-export class SolidCreateModelWithFieldsMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidCreateModelWithFieldsMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly moduleMetadataService: ModuleMetadataService,
         private readonly modelMetadataService: ModelMetadataService,
-        private readonly solidRegistry: SolidRegistry,
     ) {
     }
 
@@ -22,17 +19,18 @@ export class SolidCreateModelWithFieldsMcpToolResponseHandler implements IMcpToo
         const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
         const aiResponseMessage = JSON.parse(escapedMessage);
 
-        const { moduleUserKey, ...modelSchema } = aiResponseMessage;
+        const { generation_status, instructions, data } = aiResponseMessage;
+        const { moduleUserKey, schema } = data;
         const moduleMetadata = await this.moduleMetadataService.findOneByUserKey(moduleUserKey);
         if (!moduleMetadata) {
             throw new Error(`Module with user key ${moduleUserKey} not found.`);
         }
-        modelSchema['moduleId'] = moduleMetadata.id;
+        schema['moduleId'] = moduleMetadata.id;
 
         // TODO: Validate if another model with same name exists, if it does then raise an error...
 
         // This creates the module-metadata.json file....
-        const modelObj = await this.modelMetadataService.create(modelSchema as CreateModelMetadataDto);
+        const modelObj = await this.modelMetadataService.create(schema as CreateModelMetadataDto);
 
         // Now we need to run solid seed & then solid refresh-model --name <module-name>
         await this.modelMetadataService.handleGenerateCode({ modelId: modelObj.id });

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

@@ -1,12 +1,12 @@
 import { Injectable } from "@nestjs/common";
-import { IMcpToolResponseHandler } from "../../interfaces";
+import { IMcpToolResponseHandler } from "../../../interfaces";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
-import { ModuleMetadataService } from "../module-metadata.service";
+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 {
+export class SolidCreateModuleMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly moduleMetadataService: ModuleMetadataService,
@@ -16,9 +16,12 @@ export class SolidCreateModuleMcpToolResponseHandler implements IMcpToolResponse
     }
 
     async apply(aiInteraction: AiInteraction) {
-        const aiResponseMessage = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
 
-        const moduleMetadata = aiResponseMessage?.moduleMetadata ?? {};
+        const { generation_status, instructions, data } = aiResponseMessage;
+        const { schema } = data;
+        const { moduleMetadata } = schema;
 
         // TODO: Validate if another module with same name exists, if it does then raise an error...
 

package/src/services/{mcp-tool-response-handlers/solid-save-model-layout-mcp-tool-response-handler.service.ts → genai/mcp-handlers/solid-update-layout-mcp-handler.service.ts}

@@ -1,10 +1,10 @@
 import { Injectable } from "@nestjs/common";
 import { AiInteraction } from "src/entities/ai-interaction.entity";
 import { ViewMetadataRepository } from "src/repository/view-metadata.repository";
-import { IMcpToolResponseHandler } from "../../interfaces";
+import { IMcpToolResponseHandler } from "../../../interfaces";
 
 @Injectable()
-export class SolidCreateModelLayoutMcpToolResponseHandler implements IMcpToolResponseHandler {
+export class SolidUpdateLayoutMcpHandler implements IMcpToolResponseHandler {
 
     constructor(
         private readonly viewMetadataRepository: ViewMetadataRepository,
@@ -12,15 +12,21 @@ export class SolidCreateModelLayoutMcpToolResponseHandler implements IMcpToolRes
     }
 
     async apply(aiInteraction: AiInteraction) {
-        const aiResponse = JSON.parse(aiInteraction.message);
+        // const aiResponse = JSON.parse(aiInteraction.message);
+        const escapedMessage = aiInteraction.message.replace(/\\'/g, "'");
+        const aiResponseMessage = JSON.parse(escapedMessage);
 
         // Get the data for resolving the view metadata
-        const {name, modelUserKey, moduleUserKey, layout} = aiResponse;
+        const { data } = aiResponseMessage;
+        const { moduleUserKey, modelUserKey, view, schema: layout } = data;
 
         // Fetch the view metadata for the given model and module and the view name
-        const viewMetadata = await this.viewMetadataRepository.findByNameAndModelNameAndModuleName(name, modelUserKey, moduleUserKey);
+        const viewMetadata = await this.viewMetadataRepository.findByTypeModelNameAndModuleName(view, modelUserKey, moduleUserKey);
+
+        // TODO: Validation to check if we were able to resolve the right view.
 
         viewMetadata.layout = JSON.stringify(layout);
+
         // Save the updated view metadata
         await this.viewMetadataRepository.save(viewMetadata);
 

package/src/services/import-transaction.service.ts

@@ -659,10 +659,10 @@ export class ImportTransactionService extends CRUDService<ImportTransaction> {
         return dtoRecord;
       }
      // Use flexible date parser
-     console.log(cellValue,'cellValue');
+     this.logger.verbose(cellValue,'cellValue');
      
   const dateValue = parseFlexibleDate(cellValue);
-  console.log(dateValue,'dateValue');
+  this.logger.verbose(dateValue,'dateValue');
 
   if (!dateValue) {
     throw new Error(