@solidxai/core 0.1.10-beta.25 → 0.1.10-beta.27

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

@@ -1,98 +0,0 @@
-import { Injectable, Logger } from '@nestjs/common';
-
-import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
-import { QueueMessage } from 'src/interfaces/mq';
-import triggerMcpClientQueueConfig from './trigger-mcp-client-queue-options-redis';
-import { MqMessageService } from '../../services/mq-message.service';
-import { MqMessageQueueService } from '../../services/mq-message-queue.service';
-import { TriggerMcpClientOptions, QueuesModuleOptions } from "../../interfaces";
-import { AiInteractionService } from '../../services/ai-interaction.service';
-import { PollerService } from '../../services/poller.service';
-
-@Injectable()
-export class TriggerMcpClientSubscriberRedis extends RedisSubscriber<TriggerMcpClientOptions> {
-    private readonly triggerMcpClientSubscriberLogger = new Logger(TriggerMcpClientSubscriberRedis.name);
-
-    constructor(
-        readonly mqMessageService: MqMessageService,
-        readonly mqMessageQueueService: MqMessageQueueService,
-        readonly poller: PollerService,
-        readonly aiInteractionService: AiInteractionService,
-    ) {
-        super(mqMessageService, mqMessageQueueService);
-    }
-
-    options(): QueuesModuleOptions {
-        return {
-            ...triggerMcpClientQueueConfig
-        }
-    }
-
-    async subscribe(message: QueueMessage<TriggerMcpClientOptions>) {
-        this.triggerMcpClientSubscriberLogger.debug(`Received message: ${JSON.stringify(message)}`);
-
-        const codeGnerationOptions = message.payload;
-
-        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);
-        }
-
-        const prompt = aiInteraction.message;
-
-        const aiResponse = await this.aiInteractionService.runMcpPrompt(prompt);
-        this.triggerMcpClientSubscriberLogger.log(`aiResponse: `);
-        this.triggerMcpClientSubscriberLogger.log(JSON.stringify(aiResponse));
-
-        if (!aiResponse.success) {
-            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,
-                parentInteractionId: aiInteraction.id,
-                role: 'gen-ai',
-                message: '-',
-                contentType: aiResponse.content_type,
-                errorMessage: errorsStr,
-                modelUsed: aiResponse.model,
-                responseTimeMs: aiResponse.duration_ms,
-                metadata: JSON.stringify(aiResponse),
-                isApplied: aiInteraction.isApplied,
-                status: aiResponse.success ? 'succeeded' : 'failed'
-            });
-
-            throw new Error(errorsStr);
-        }
-        else {
-            let nestedResponse = aiResponse.response.trim();
-
-            const genAiInteraction = await this.aiInteractionService.create({
-                userId: aiInteraction.user.id,
-                threadId: aiInteraction.threadId,
-                parentInteractionId: aiInteraction.id,
-                role: 'gen-ai',
-                message: nestedResponse,
-                contentType: aiResponse.content_type,
-                errorMessage: '',
-                modelUsed: aiResponse.model,
-                responseTimeMs: aiResponse.duration_ms,
-                metadata: JSON.stringify(aiResponse),
-                isApplied: aiInteraction.isApplied,
-                status: aiResponse.success ? 'succeeded' : 'failed'
-            });
-
-            if (aiInteraction.isAutoApply) {
-                this.aiInteractionService.applySolidAiInteraction(genAiInteraction.id);
-            }
-        }
-
-        return aiResponse;
-    }
-}

package/src/repository/ai-interaction.repository.ts

@@ -1,17 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AiInteraction } from 'src/entities/ai-interaction.entity';
-import { RequestContextService } from 'src/services/request-context.service';
-import { DataSource } from 'typeorm';
-import { SecurityRuleRepository } from './security-rule.repository';
-import { SolidBaseRepository } from './solid-base.repository';
-
-@Injectable()
-export class AiInteractionRepository extends SolidBaseRepository<AiInteraction> {
-    constructor(
-        readonly dataSource: DataSource,
-        readonly requestContextService: RequestContextService,
-        readonly securityRuleRepository: SecurityRuleRepository,
-    ) {
-        super(AiInteraction, dataSource, requestContextService, securityRuleRepository);
-    }
-}

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

@@ -1,239 +0,0 @@
-import { BadRequestException, Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from "@nestjs/core";
-import { InjectEntityManager } from '@nestjs/typeorm';
-import { EntityManager } from 'typeorm';
-import type { SolidCoreSetting } from "src/services/settings/default-settings-provider.service";
-
-import { spawn } from 'child_process';
-import * as fs from 'fs/promises';
-import { ERROR_MESSAGES } from 'src/constants/error-messages';
-import { InvokeAiPromptDto } from 'src/dtos/invoke-ai-prompt.dto';
-import { McpResponse, TriggerMcpClientOptions } from 'src/interfaces';
-import { AiInteractionRepository } from 'src/repository/ai-interaction.repository';
-import { CRUDService } from 'src/services/crud.service';
-import { AiInteraction } from '../entities/ai-interaction.entity';
-import { McpHandlerFactory } from './genai/mcp-handlers/mcp-handler-factory.service';
-import { PublisherFactory } from './queues/publisher-factory.service';
-
-@Injectable()
-export class AiInteractionService extends CRUDService<AiInteraction> {
-  private readonly logger = new Logger(AiInteractionService.name);
-
-  constructor(
-    @InjectEntityManager()
-    readonly entityManager: EntityManager,
-    // @InjectRepository(AiInteraction, 'default')
-    // readonly repo: Repository<AiInteraction>,
-    readonly repo: AiInteractionRepository,
-    readonly moduleRef: ModuleRef,
-    readonly publisherFactory: PublisherFactory<TriggerMcpClientOptions>,
-    // readonly requestContextService: RequestContextService,
-    readonly mcpHandlerFactory: McpHandlerFactory,
-
-  ) {
-    super(entityManager, repo, 'aiInteraction', 'solid-core', moduleRef);
-  }
-
-  async triggerMcpClientJob(dto: InvokeAiPromptDto, userId: number, isAutoApply: boolean = false, threadId: string = null): Promise<any> {
-    // const activeUser: ActiveUserData = this.requestContextService.getActiveUser();
-
-    const aiInteraction = await this.create({
-      userId: userId,
-      threadId: threadId ? threadId : `thread-${userId}`,
-      role: 'human',
-      message: dto.prompt,
-      contentType: '',
-      errorMessage: '',
-      modelUsed: '',
-      responseTimeMs: 0,
-      metadata: '',
-      isAutoApply: isAutoApply
-    });
-    const m = {
-      payload: {
-        aiInteractionId: aiInteraction.id,
-        moduleName: dto.moduleName
-      },
-      parentEntity: 'aiInteraction',
-      parentEntityId: aiInteraction.id,
-    };
-
-    const queueMessageId = await this.publisherFactory.publish(m, 'TriggerMcpClientPublisher');
-
-    return {
-      queueMessageId: queueMessageId,
-      aiInteractionId: aiInteraction.id
-    }
-  }
-
-  /**
-   * Runs the Python MCP client with a prompt and returns the parsed JSON embedded in the 'response'.
-   * @param prompt - The question or instruction to send to the MCP client.
-   * @returns The parsed object inside the 'response' field of the JSON output.
-   */
-  async runMcpPrompt(prompt: string): Promise<McpResponse> {
-    const pythonExecutable = this.settingService.getConfigValue<SolidCoreSetting>('mcpPythonExecutable');
-    const mcpClient = this.settingService.getConfigValue<SolidCoreSetting>('mcpClient');
-
-    // TODO: We can return an error if the above env variables are not properly setup...
-    if (!pythonExecutable || !mcpClient) {
-      throw new BadRequestException(ERROR_MESSAGES.PYTHON_EXECUTABLE_NOT_CONFIGURED);
-    }
-
-    // Check if both paths are valid and accessible
-    try {
-      const [pyStat, clientStat] = await Promise.all([
-        fs.stat(pythonExecutable),
-        fs.stat(mcpClient),
-      ]);
-
-      if (!pyStat.isFile()) {
-        throw new BadRequestException(`MCP_PYTHON_EXECUTABLE path is not a file: ${pythonExecutable}`);
-      }
-
-      if (!clientStat.isFile()) {
-        throw new BadRequestException(`MCP_CLIENT path is not a file: ${mcpClient}`);
-      }
-
-    } catch (err: any) {
-      throw new BadRequestException(`Invalid MCP executable or client path: ${err.message}`);
-    }
-
-    // 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}"`);
-
-      const python = spawn(pythonExecutable, [mcpClient, `"${prompt}"`]);
-
-      let stdout = '';
-      let stderr = '';
-
-      python.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      python.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      python.on('close', (code) => {
-        this.logger.log(`Python script exited with code ${code}`);
-
-        if (code !== 0) {
-          this.logger.error(`Python script exited with a non-zero exit code: ${stderr}`);
-          return reject(new Error(`Python script exited with a non-zero exit code: ${stderr}`));
-        }
-
-        try {
-          this.logger.log(`Python script exited with zero exit code: ${stdout}`);
-          const raw: McpResponse = JSON.parse(stdout);
-
-          // Sometimes the raw.response might not be a valid json
-          // TODO: examine the content type of the raw response..
-          // if (raw.content_type==='json') {
-          // }
-          let parsedResponse = raw.response;
-          try {
-            parsedResponse = JSON.parse(raw.response);
-          }
-          catch (ex) {
-            this.logger.warn(`Attempting to parse mcp client response assuming it is JSON, however it is not: ${parsedResponse}`);
-            // raw.success = false
-          }
-          // Parse the response string into an object
-          // const parsedResponse = JSON.parse(raw.response);
-
-          // Replace the string with the parsed object
-          const enrichedRaw = {
-            ...raw,
-            response: parsedResponse,
-          };
-          // if (!raw.success) {
-          //   return reject(new Error(`MCP error: ${raw.errors?.join(', ')}`));
-          // }
-          // let cleaned = raw.response.trim();
-
-          // Don't need to re-parse this...
-          // const parsed = JSON.parse(cleaned);
-          // resolve(cleaned);
-
-          resolve(enrichedRaw);
-        } catch (err: any) {
-          reject(new Error(`Mcp Invocation Failed: ${err.message}`));
-        }
-      });
-    });
-  }
-
-  cleanResponse(response: string) {
-    this.logger.log(`mcp server response is: ${response}`);
-
-    // Remove markdown-style code block wrapper
-    if (response.startsWith('```json')) {
-      response = response.replace(/^```json/, '').trim();
-    }
-    if (response.endsWith('```')) {
-      response = response.replace(/```$/, '').trim();
-    }
-    this.logger.log(`mcp server response after removing doc tags is: ${response}`);
-
-    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: any = {};
-    try {
-      if (typeof aiInteraction.metadata === "string") {
-        metadata = JSON.parse(aiInteraction.metadata);
-      } else if (typeof aiInteraction.metadata === "object" && aiInteraction.metadata !== null) {
-        metadata = aiInteraction.metadata;
-      } else {
-        // optional fallback
-        metadata = {};
-      }
-    } catch (e) {
-      // TODO: RESPONSE SHAPE ALERT Check if we want to control the shape of the response....
-      throw new Error(`Invalid metadata JSON: ${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(ERROR_MESSAGES.UNABLE_TO_RESOLVE_SOLID_COMMAND);
-    }
-
-    // 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.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);
-    }
-
-    const handlerApplicationResponse = await mcpToolHandler.apply(aiInteraction);
-
-    // TODO: This provider to implement an interface - IMcpToolResponseHandler ... apply(aiInteraction: AiInteraction)
-    // throw new Error('Method not implemented.');
-
-    // Mark the interaction as applied
-    await this.update(aiInteraction.id, { isApplied: true }, [], true);
-
-    return handlerApplicationResponse;
-  }
-}

package/src/services/database/database-bootstrap.service.ts

@@ -1,91 +0,0 @@
-import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
-import { DataSource } from 'typeorm';
-import { readdir, readFile } from 'fs/promises';
-import * as path from 'path';
-import { InjectDataSource } from '@nestjs/typeorm';
-
-@Injectable()
-export class DatabaseBootstrapService implements OnModuleInit {
-  private readonly logger = new Logger(DatabaseBootstrapService.name);
-
-  constructor(
-    @InjectDataSource()
-    private readonly dataSource: DataSource,
-  ) { }
-
-  async onModuleInit() {
-    if (!this.dataSource.isInitialized) {
-      this.logger.warn(`[${this.dataSource.name}] DataSource not initialized. Skipping SQL bootstrap.`);
-      return;
-    }
-
-    this.logger.debug(`[${this.dataSource.name}] Bootstrapping stored procedures...`);
-
-    await this.applyAllSqlFiles();
-
-    this.logger.debug(`[${this.dataSource.name}] SQL bootstrap completed`);
-  }
-
-  private resolveSqlDirectory(): string {
-    const datasourceName = this.dataSource.name || 'default';
-    const dbType = this.dataSource.options.type;
-
-    const sqlFilePath = path.resolve(__dirname, `../../../sql/${datasourceName}/${dbType}`);
-
-    return sqlFilePath
-  }
-
-  private async applyAllSqlFiles() {
-    const sqlDir = this.resolveSqlDirectory();
-
-    this.logger.debug(`[${this.dataSource.name}] SQL directory: ${sqlDir}`);
-
-    let files: string[];
-    try {
-      files = await readdir(sqlDir);
-    } catch {
-      this.logger.warn(
-        `[${this.dataSource.name}] No SQL directory found. Skipping.`,
-      );
-      return;
-    }
-
-    const sqlFiles = files
-      .filter(file => file.endsWith('.sql'))
-      .sort();
-
-    if (!sqlFiles.length) {
-      this.logger.warn(
-        `[${this.dataSource.name}] No SQL files found`,
-      );
-      return;
-    }
-
-    for (const file of sqlFiles) {
-      await this.applySqlFileSafely(
-        path.join(sqlDir, file),
-        file,
-      );
-    }
-  }
-
-  private async applySqlFileSafely(
-    filePath: string,
-    fileName: string,
-  ) {
-    this.logger.debug(`[${this.dataSource.name}] Applying ${fileName}`);
-
-    try {
-      const sql = await readFile(filePath, 'utf8');
-      await this.dataSource.query(sql);
-
-      this.logger.debug(`[${this.dataSource.name}] Applied ${fileName}`);
-    } catch (error: any) {
-      // DO NOT THROW — continue with next file
-      this.logger.error(
-        `[${this.dataSource.name}] Failed ${fileName}`,
-        error instanceof Error ? error.stack : String(error),
-      );
-    }
-  }
-}