@solidxai/core 0.1.7 → 0.1.8-beta.1

package/src/jobs/redis/three60-whatsapp-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import three60WhatsappQueueConfig from './three60-whatsapp-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { Three60WhatsappService } from '../../services/whatsapp/Three60WhatsappService';
+
+@Injectable()
+export class Three60WhatsappQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly whatsappService: Three60WhatsappService,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...three60WhatsappQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        this.whatsappService.sendWhatsAppMessageSynchronously(message);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import triggerMcpClientQueueConfig from './trigger-mcp-client-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { TriggerMcpClientOptions, QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class TriggerMcpClientPublisherRedis extends RedisPublisher<TriggerMcpClientOptions> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...triggerMcpClientQueueConfig
+        }
+    }
+}

package/src/jobs/redis/trigger-mcp-client-queue-options-redis.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'solid_trigger_mcp_client_queue_redis';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Redis,
+    queueName: QUEUE_NAME,
+};

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

@@ -0,0 +1,98 @@
+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/jobs/redis/twilio-sms-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import twilioSmsQueueConfig from './twilio-sms-queue-options-redis';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { MqMessageService } from '../../services/mq-message.service';
+import { QueuesModuleOptions } from "../../interfaces";
+
+@Injectable()
+export class TwilioSmsQueuePublisherRedis extends RedisPublisher<any> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...twilioSmsQueueConfig
+        }
+    }
+}

package/src/jobs/redis/twilio-sms-queue-options-redis.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "../../interfaces";
+
+const QUEUE_NAME = 'solid_twilio_sms_queue_redis';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Redis,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/redis/twilio-sms-subscriber-redis.service.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import { QueueMessage } from 'src/interfaces/mq';
+import twilioSmsQueueConfig from './twilio-sms-queue-options-redis';
+import { MqMessageService } from '../../services/mq-message.service';
+import { MqMessageQueueService } from '../../services/mq-message-queue.service';
+import { QueuesModuleOptions } from "../../interfaces";
+import { TwilioSMSService } from '../../services/sms/TwilioSMSService';
+import { SmsFactory } from 'src/factories/sms.factory';
+import { PollerService } from '../../services/poller.service';
+
+@Injectable()
+export class TwilioSmsQueueSubscriberRedis extends RedisSubscriber<any> {
+    constructor(
+        private readonly smsFactory: SmsFactory,
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...twilioSmsQueueConfig
+        }
+    }
+
+    subscribe(message: QueueMessage<any>) {
+        const smsService: TwilioSMSService = this.smsFactory.getSmsService(TwilioSMSService.name) as TwilioSMSService;
+        return smsService.sendSMSSynchronously(message);
+    }
+}

package/src/repository/agent-event.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { AgentEvent } from 'src/entities/agent-event.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 AgentEventRepository extends SolidBaseRepository<AgentEvent> {
+  constructor(
+    readonly dataSource: DataSource,
+    readonly requestContextService: RequestContextService,
+    readonly securityRuleRepository: SecurityRuleRepository,
+  ) {
+    super(AgentEvent, dataSource, requestContextService, securityRuleRepository);
+  }
+}

package/src/repository/agent-session.repository.ts

@@ -0,0 +1,17 @@
+import { Injectable } from '@nestjs/common';
+import { AgentSession } from 'src/entities/agent-session.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 AgentSessionRepository extends SolidBaseRepository<AgentSession> {
+  constructor(
+    readonly dataSource: DataSource,
+    readonly requestContextService: RequestContextService,
+    readonly securityRuleRepository: SecurityRuleRepository,
+  ) {
+    super(AgentSession, dataSource, requestContextService, securityRuleRepository);
+  }
+}