@solidstarters/solid-core 1.2.136 → 1.2.137

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidstarters/solid-core",
-  "version": "1.2.136",
+  "version": "1.2.137",
   "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/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/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/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,52 @@
+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 {}
+    }
+
+}

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/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,