@solidxai/core 0.1.7 → 0.1.8-beta.1

package/src/services/agent-event.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { AgentEvent } from 'src/entities/agent-event.entity';
+import { AgentEventRepository } from 'src/repository/agent-event.repository';
+import { EntityManager } from 'typeorm';
+import { CRUDService } from './crud.service';
+
+@Injectable()
+export class AgentEventService extends CRUDService<AgentEvent> {
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: AgentEventRepository,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'agentEvent', 'solid-core', moduleRef);
+  }
+}

package/src/services/agent-session.service.ts

@@ -0,0 +1,19 @@
+import { Injectable } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { InjectEntityManager } from '@nestjs/typeorm';
+import { AgentSession } from 'src/entities/agent-session.entity';
+import { AgentSessionRepository } from 'src/repository/agent-session.repository';
+import { EntityManager } from 'typeorm';
+import { CRUDService } from './crud.service';
+
+@Injectable()
+export class AgentSessionService extends CRUDService<AgentSession> {
+  constructor(
+    @InjectEntityManager()
+    readonly entityManager: EntityManager,
+    readonly repo: AgentSessionRepository,
+    readonly moduleRef: ModuleRef,
+  ) {
+    super(entityManager, repo, 'agentSession', 'solid-core', moduleRef);
+  }
+}

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

@@ -551,6 +551,7 @@ export class ModelMetadataService {
     return removedEntities
   }
 
+  @DisallowInProduction()
   async remove(id: number) {
     const entity = await this.findOne(id);
     await this.cleanupOnDelete(entity.id);

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

@@ -326,15 +326,14 @@ export class ModuleMetadataService {
     }
   }
 
+  @DisallowInProduction()
   async remove(id: number) {
     const entity = await this.findOne(id);
     await this.cleanupOnDelete(entity.id);
     const r = await this.moduleMetadataRepo.remove(entity);
     return r
-
   }
 
-
   async cleanupOnDelete(moduleEntityId: number) {
     const moduleEntity = await this.moduleMetadataRepo.findOne({
       where: {

package/src/services/queues/redis-publisher.service.ts

@@ -0,0 +1,94 @@
+import { Logger, OnModuleDestroy } from '@nestjs/common';
+import Redis from 'ioredis';
+import { v4 as uuidv4 } from 'uuid';
+import { QueuesModuleOptions } from '../../interfaces';
+import { QueueMessage, QueuePublisher } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+import { buildNamespacedQueueName } from './common';
+
+export abstract class RedisPublisher<T> implements OnModuleDestroy, QueuePublisher<T> {
+    private readonly logger = new Logger(RedisPublisher.name);
+    private readonly serviceRole: string;
+    private client: Redis | null = null;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!process.env.QUEUES_REDIS_URL) {
+            this.logger.debug('RedisPublisher: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+    }
+
+    abstract options(): QueuesModuleOptions;
+
+    private getClient(): Redis {
+        if (!this.client) {
+            this.client = new Redis(process.env.QUEUES_REDIS_URL);
+            this.client.on('error', (err) => {
+                this.logger.error(`RedisPublisher connection error: ${err.message}`, err.stack);
+            });
+        }
+        return this.client;
+    }
+
+    async onModuleDestroy(): Promise<void> {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+        }
+    }
+
+    async publish(message: QueueMessage<T>): Promise<string> {
+        if (!process.env.QUEUES_REDIS_URL) {
+            throw new Error('RedisPublisher: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+        if (!this.serviceRole) {
+            throw new Error('RedisPublisher: Queue service Role is not defined in the environment variables');
+        }
+        if (this.serviceRole === 'subscriber') {
+            throw new Error('RedisPublisher: Queue service Role is subscriber, cannot publish messages');
+        }
+
+        if (!message.retryCount) message.retryCount = 0;
+        if (!message.retryInterval) message.retryInterval = 1000;
+        message.messageId = uuidv4();
+
+        const queueName = this.options().queueName;
+        const namespacedQueueName = buildNamespacedQueueName(queueName);
+
+        await this.persistToDatabase(namespacedQueueName, message);
+
+        try {
+            const client = this.getClient();
+            await client.publish(namespacedQueueName, JSON.stringify(message));
+            this.logger.debug(`RedisPublisher published message ${message.messageId} to channel ${namespacedQueueName}`);
+        } catch (err) {
+            this.logger.error(`RedisPublisher failed to publish message: ${(err as Error).message}`, (err as Error).stack);
+        }
+
+        return message.messageId;
+    }
+
+    private async persistToDatabase(queueName: string, message: QueueMessage<T>): Promise<void> {
+        try {
+            const mqMessageQueue = await this.mqMessageQueueService.resolveQueue(queueName);
+            await this.mqMessageService.create({
+                messageBroker: this.options().type,
+                messageId: message.messageId,
+                retryCount: message.retryCount,
+                retryInterval: message.retryInterval,
+                stage: 'pending',
+                startedAt: new Date(),
+                input: JSON.stringify(message, null, 2),
+                parentEntityId: message.parentEntityId,
+                parentEntity: message.parentEntity,
+                mqMessageQueueId: mqMessageQueue.id,
+            });
+        } catch (error) {
+            this.logger.error(error.message, error.stack);
+        }
+    }
+}

package/src/services/queues/redis-subscriber.service.ts

@@ -0,0 +1,208 @@
+import { Logger, OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import Redis from 'ioredis';
+import { QueuesModuleOptions } from '../../interfaces';
+import { QueueMessage, QueueSubscriber } from '../../interfaces/mq';
+import { MqMessageQueueService } from '../mq-message-queue.service';
+import { MqMessageService } from '../mq-message.service';
+import { buildNamespacedQueueName } from './common';
+
+export abstract class RedisSubscriber<T> implements OnModuleInit, OnModuleDestroy, QueueSubscriber<T> {
+    private readonly logger = new Logger(RedisSubscriber.name);
+    private readonly serviceRole: string;
+    private client: Redis | null = null;
+    private reconnectAttempt = 0;
+    private stopping = false;
+
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        this.serviceRole = process.env.QUEUES_SERVICE_ROLE;
+        if (!process.env.QUEUES_REDIS_URL) {
+            this.logger.debug('RedisSubscriber: QUEUES_REDIS_URL is not defined in the environment variables');
+        }
+    }
+
+    abstract subscribe(message: QueueMessage<T>): void;
+
+    abstract options(): QueuesModuleOptions;
+
+    async onModuleInit(): Promise<void> {
+        const defaultBroker = process.env.QUEUES_DEFAULT_BROKER || 'database';
+        const solidCliRunning = process.env.SOLID_CLI_RUNNING || 'false';
+        const queueNameRegex = (process.env.QUEUES_QUEUE_NAME_REGEX_TO_ENABLE || '').trim();
+
+        if (
+            process.env.QUEUES_REDIS_URL &&
+            ['both', 'subscriber'].includes(this.serviceRole) &&
+            solidCliRunning === 'false' &&
+            defaultBroker === 'redis'
+        ) {
+            const options = this.options();
+            const queueName = options.queueName;
+
+            if (queueNameRegex && queueNameRegex !== 'all') {
+                try {
+                    const regex = new RegExp(queueNameRegex);
+                    if (!regex.test(queueName)) {
+                        this.logger.log(
+                            `RedisSubscriber for queue ${queueName} is disabled because it does not match QUEUES_QUEUE_NAME_REGEX_TO_ENABLE=${queueNameRegex}`,
+                        );
+                        return;
+                    }
+                } catch (error) {
+                    this.logger.error(
+                        `Invalid QUEUES_QUEUE_NAME_REGEX_TO_ENABLE regex "${queueNameRegex}". Subscriber for queue ${queueName} will not start.`,
+                    );
+                    return;
+                }
+            }
+
+            const namespacedQueueName = buildNamespacedQueueName(queueName);
+            await this.connectAndSubscribe(namespacedQueueName);
+            this.logger.log(`RedisSubscriber ready to consume messages: ${JSON.stringify(options)}`);
+        }
+    }
+
+    async onModuleDestroy(): Promise<void> {
+        this.stopping = true;
+        await this.cleanup();
+    }
+
+    private async connectAndSubscribe(channel: string): Promise<void> {
+        await this.cleanup();
+
+        const client = new Redis(process.env.QUEUES_REDIS_URL);
+        this.client = client;
+
+        client.on('error', (err) => {
+            if (client !== this.client) return;
+            this.logger.error(`RedisSubscriber connection error for channel ${channel}: ${err.message}`, err.stack);
+        });
+
+        client.on('close', () => {
+            if (client !== this.client) return;
+            this.logger.warn(`RedisSubscriber connection closed for channel ${channel}`);
+            this.triggerReconnect(channel, 'connection closed');
+        });
+
+        client.on('message', async (receivedChannel, rawMessage) => {
+            if (receivedChannel !== channel) return;
+
+            let message: QueueMessage<T> = null;
+            try {
+                message = JSON.parse(rawMessage) as QueueMessage<T>;
+            } catch (error) {
+                this.logger.error(`RedisSubscriber invalid JSON on channel ${channel}: ${(error as Error).message}`);
+                return;
+            }
+
+            if (!message.retryCount) message.retryCount = 0;
+            if (!message.retryInterval) message.retryInterval = 1000;
+            if (!message.currentRetry) message.currentRetry = 0;
+
+            try {
+                await this.processMessage(message);
+            } catch (error) {
+                await this.handleProcessingError(message, error, channel);
+            }
+        });
+
+        await client.subscribe(channel);
+        this.reconnectAttempt = 0;
+    }
+
+    private async handleProcessingError(message: QueueMessage<T>, error: any, channel: string): Promise<void> {
+        const errorMessage = (error as Error)?.message || String(error);
+        this.logger.error(`Error processing message on channel ${channel}: ${errorMessage}`);
+
+        if (message.currentRetry < message.retryCount) {
+            await this.updateStatusInDatabase('retrying', message);
+            message.currentRetry++;
+            this.logger.warn(
+                `Retrying message (${message.currentRetry}/${message.retryCount}) after ${message.retryInterval}ms on channel ${channel}`,
+            );
+            setTimeout(async () => {
+                try {
+                    await this.processMessage(message);
+                } catch (retryError) {
+                    await this.handleProcessingError(message, retryError, channel);
+                }
+            }, message.retryInterval);
+        } else {
+            await this.updateStatusInDatabase('failed', message, errorMessage, '');
+            this.logger.error(`Message failed after ${message.retryCount} attempts on channel ${channel}: ${errorMessage}`);
+        }
+    }
+
+    private triggerReconnect(channel: string, reason: string): void {
+        if (this.stopping) return;
+
+        this.reconnectAttempt++;
+        const delay = this.backoff();
+        this.logger.warn(`RedisSubscriber reconnecting for channel ${channel} (${reason}) in ${delay}ms`);
+
+        setTimeout(async () => {
+            if (this.stopping) return;
+            try {
+                await this.connectAndSubscribe(channel);
+                this.logger.log(`RedisSubscriber reconnected for channel ${channel}`);
+            } catch (err) {
+                this.triggerReconnect(channel, `reconnect failed: ${(err as Error).message}`);
+            }
+        }, delay);
+    }
+
+    private async cleanup(): Promise<void> {
+        const client = this.client;
+        this.client = null;
+
+        if (client) {
+            try {
+                await client.quit();
+            } catch (_) {
+                // ignore
+            }
+        }
+    }
+
+    private backoff(): number {
+        const baseMs = 1000;
+        const maxMs = 30_000;
+        const exp = Math.min(maxMs, baseMs * Math.pow(2, this.reconnectAttempt));
+        const jitter = Math.floor(Math.random() * (exp * 0.2));
+        return Math.min(maxMs, exp + jitter);
+    }
+
+    protected async processMessage(message: QueueMessage<T>): Promise<void> {
+        await this.updateStatusInDatabase('started', message);
+        const result: any = await (this.subscribe(message) as any);
+        await this.updateStatusInDatabase('succeeded', message, '', result != null ? JSON.stringify(result, null, 2) : '');
+    }
+
+    private async updateStatusInDatabase(
+        stage: string,
+        message: QueueMessage<T>,
+        error: string = '',
+        result: string = '',
+    ): Promise<void> {
+        try {
+            const mqMessage = await this.mqMessageService.repo.findOne({
+                where: { messageId: message.messageId },
+            });
+
+            if (mqMessage) {
+                const updatedFields: Record<string, any> = { stage };
+                if (stage === 'failed' || stage === 'succeeded') {
+                    updatedFields['finishedAt'] = new Date();
+                    updatedFields['elapsedMillis'] = updatedFields['finishedAt'].getTime() - mqMessage.startedAt.getTime();
+                }
+                if (stage === 'succeeded') updatedFields['output'] = result;
+                if (stage === 'failed') updatedFields['error'] = error;
+                await this.mqMessageService.repo.update(mqMessage.id, updatedFields);
+            }
+        } catch (err) {
+            this.logger.error(err.message, err.stack);
+        }
+    }
+}

package/src/services/settings/default-settings-provider.service.ts

@@ -34,8 +34,8 @@ const getSolidCoreSettings = (isProd: boolean) => ([
   { moduleName: "solid-core", key: "authScreenCenterBackgroundImage", value: null, level: SettingLevel.SystemAdminEditable },
   {
     moduleName: "solid-core", key: "solidXGenAiCodeBuilderConfig", value: JSON.stringify({
-      defaultProvider: "",
-      availableProviders: []
+      fastModel: { provider: "", availableProviders: [] },
+      defaultProvider: { provider: "", availableProviders: [] },
     }), level: SettingLevel.SystemAdminEditable
   },
   { moduleName: "solid-core", key: "mcpEnabled", value: process.env.MCP_ENABLED || false, level: SettingLevel.SystemAdminReadonly },

package/src/services/user-activity-history.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { InjectEntityManager } from '@nestjs/typeorm';
 import { ModuleRef } from "@nestjs/core";
 import { EntityManager } from 'typeorm';
@@ -13,6 +13,8 @@ import { UserActivityHistoryRepository } from 'src/repository/user-activity-hist
 
 @Injectable()
 export class UserActivityHistoryService extends CRUDService<UserActivityHistory> {
+  private readonly _logger = new Logger(UserActivityHistoryService.name);
+
   constructor(
     @InjectEntityManager()
     readonly entityManager: EntityManager,
@@ -26,15 +28,19 @@ export class UserActivityHistoryService extends CRUDService<UserActivityHistory>
     super(entityManager, repo, 'userActivityHistory', 'solid-core', moduleRef);
   }
   async logEvent(event: 'login' | 'logout' | 'tokenRefreshed', user: User) {
-    const ip = this.requestContextService.getIp();
-    const userAgent = this.requestContextService.getUserAgent();
-
-    await this.repo.save({
-      user,
-      event,
-      ipAddress: ip,
-      userAgent,
-    });
+    try {
+      const ip = this.requestContextService.getIp();
+      const userAgent = this.requestContextService.getUserAgent();
+
+      await this.repo.save({
+        user,
+        event,
+        ipAddress: ip,
+        userAgent,
+      });
+    } catch (err) {
+      this._logger.warn(`Failed to log event "${event}" for user ${user?.id}: ${err}`);
+    }
   }
 
 }

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

@@ -144,7 +144,7 @@ export class ViewMetadataService extends CRUDService<ViewMetadata> {
         .leftJoinAndSelect('action.view', 'view')
         .where('model.id = :modelId', { modelId: menuItemModelId })
         .andWhere('module.id = :moduleId', { moduleId: menuItemModuleId })
-        .andWhere('view.type IN (:...viewTypes)', { viewTypes: ['list', 'kanban', 'tree'] })
+        .andWhere('view.type IN (:...viewTypes)', { viewTypes: ['card', 'list', 'kanban', 'tree'] })
         .getMany();
 
       viewModes = actionsForViewModes.map(actionItem => ({

package/src/solid-core.module.ts

@@ -82,24 +82,48 @@ import { AuthenticationGuard } from './guards/authentication.guard';
 import { PermissionsGuard } from './guards/permissions.guard';
 import { SolidRegistry } from './helpers/solid-registry';
 import { LoggingInterceptor } from './interceptors/logging.interceptor';
-import { ApiEmailQueuePublisher } from './jobs/api-email-publisher.service';
-import { ApiEmailQueueSubscriber } from './jobs/api-email-subscriber.service';
+import { ApiEmailQueuePublisher } from './jobs/rabbitmq/api-email-publisher.service';
+import { ApiEmailQueueSubscriber } from './jobs/rabbitmq/api-email-subscriber.service';
 import { TestQueuePublisherDatabase } from './jobs/database/test-queue-publisher-database.service';
 import { TestQueueSubscriberDatabase } from './jobs/database/test-queue-subscriber-database.service';
-import { Msg91WhatsappQueuePublisher } from './jobs/msg91-whatsapp-publisher.service';
-import { Msg91WhatsappQueueSubscriber } from './jobs/msg91-whatsapp-subscriber.service';
-import { Msg91OTPQueuePublisher } from './jobs/msg91-otp-publisher.service';
-import { Msg91OTPQueueSubscriber } from './jobs/msg91-otp-subscriber.service';
-import { Msg91SmsQueuePublisher } from './jobs/msg91-sms-publisher.service';
-import { Msg91SmsQueueSubscriber } from './jobs/msg91-sms-subscriber.service';
-import { SmtpEmailQueuePublisherRabbitmq } from './jobs/smtp-email-publisher.service';
-import { SmtpEmailQueueSubscriberRabbitmq } from './jobs/smtp-email-subscriber.service';
-import { ChatterQueuePublisherRabbitmq } from './jobs/chatter-queue-publisher.service';
-import { ChatterQueueSubscriberRabbitmq } from './jobs/chatter-queue-subscriber.service';
+import { TestQueuePublisherRedis } from './jobs/redis/test-queue-publisher-redis.service';
+import { TestQueueSubscriberRedis } from './jobs/redis/test-queue-subscriber-redis.service';
+import { Msg91WhatsappQueuePublisher } from './jobs/rabbitmq/msg91-whatsapp-publisher.service';
+import { Msg91WhatsappQueueSubscriber } from './jobs/rabbitmq/msg91-whatsapp-subscriber.service';
+import { Msg91OTPQueuePublisher } from './jobs/rabbitmq/msg91-otp-publisher.service';
+import { Msg91OTPQueueSubscriber } from './jobs/rabbitmq/msg91-otp-subscriber.service';
+import { Msg91SmsQueuePublisher } from './jobs/rabbitmq/msg91-sms-publisher.service';
+import { Msg91SmsQueueSubscriber } from './jobs/rabbitmq/msg91-sms-subscriber.service';
+import { SmtpEmailQueuePublisherRabbitmq } from './jobs/rabbitmq/smtp-email-publisher.service';
+import { SmtpEmailQueueSubscriberRabbitmq } from './jobs/rabbitmq/smtp-email-subscriber.service';
+import { TestQueuePublisher } from './jobs/rabbitmq/test-queue-publisher.service';
+import { TestQueueSubscriber } from './jobs/rabbitmq/test-queue-subscriber.service';
+import { ChatterQueuePublisherRabbitmq } from './jobs/rabbitmq/chatter-queue-publisher.service';
+import { ChatterQueueSubscriberRabbitmq } from './jobs/rabbitmq/chatter-queue-subscriber.service';
 import { ChatterQueuePublisherDatabase } from './jobs/database/chatter-queue-publisher-database.service';
 import { ChatterQueueSubscriberDatabase } from './jobs/database/chatter-queue-subscriber-database.service';
-import { TestQueuePublisher } from './jobs/test-queue-publisher.service';
-import { TestQueueSubscriber } from './jobs/test-queue-subscriber.service';
+import { ApiEmailQueuePublisherRedis } from './jobs/redis/api-email-publisher-redis.service';
+import { ApiEmailQueueSubscriberRedis } from './jobs/redis/api-email-subscriber-redis.service';
+import { ChatterQueuePublisherRedis } from './jobs/redis/chatter-queue-publisher-redis.service';
+import { ChatterQueueSubscriberRedis } from './jobs/redis/chatter-queue-subscriber-redis.service';
+import { ComputedFieldEvaluationPublisherRedis } from './jobs/redis/computed-field-evaluation-publisher-redis.service';
+import { ComputedFieldEvaluationSubscriberRedis } from './jobs/redis/computed-field-evaluation-subscriber-redis.service';
+import { GenerateCodePublisherRedis } from './jobs/redis/generate-code-publisher-redis.service';
+import { GenerateCodeSubscriberRedis } from './jobs/redis/generate-code-subscriber-redis.service';
+import { Msg91OTPQueuePublisherRedis } from './jobs/redis/msg91-otp-publisher-redis.service';
+import { Msg91OTPQueueSubscriberRedis } from './jobs/redis/msg91-otp-subscriber-redis.service';
+import { Msg91SmsQueuePublisherRedis } from './jobs/redis/msg91-sms-publisher-redis.service';
+import { Msg91SmsQueueSubscriberRedis } from './jobs/redis/msg91-sms-subscriber-redis.service';
+import { Msg91WhatsappQueuePublisherRedis } from './jobs/redis/msg91-whatsapp-publisher-redis.service';
+import { Msg91WhatsappQueueSubscriberRedis } from './jobs/redis/msg91-whatsapp-subscriber-redis.service';
+import { SmtpEmailQueuePublisherRedis } from './jobs/redis/smtp-email-publisher-redis.service';
+import { SmtpEmailQueueSubscriberRedis } from './jobs/redis/smtp-email-subscriber-redis.service';
+import { Three60WhatsappQueuePublisherRedis } from './jobs/redis/three60-whatsapp-publisher-redis.service';
+import { Three60WhatsappQueueSubscriberRedis } from './jobs/redis/three60-whatsapp-subscriber-redis.service';
+import { TriggerMcpClientPublisherRedis } from './jobs/redis/trigger-mcp-client-publisher-redis.service';
+import { TriggerMcpClientSubscriberRedis } from './jobs/redis/trigger-mcp-client-subscriber-redis.service';
+import { TwilioSmsQueuePublisherRedis } from './jobs/redis/twilio-sms-publisher-redis.service';
+import { TwilioSmsQueueSubscriberRedis } from './jobs/redis/twilio-sms-subscriber-redis.service';
 import { UserRegistrationListener } from './listeners/user-registration.listener';
 import { GoogleOauthStrategy } from './passport-strategies/google-oauth.strategy';
 import { AuthenticationService } from './services/authentication.service';
@@ -149,6 +173,8 @@ import { LocaleController } from './controllers/locale.controller';
 import { RoleMetadataController } from './controllers/role-metadata.controller';
 import { SavedFiltersController } from './controllers/saved-filters.controller';
 import { ScheduledJobController } from './controllers/scheduled-job.controller';
+import { AgentSessionController } from './controllers/agent-session.controller';
+import { AgentEventController } from './controllers/agent-event.controller';
 import { SecurityRuleController } from './controllers/security-rule.controller';
 import { SettingController } from './controllers/setting.controller';
 import { InfoController } from './controllers/info.controller';
@@ -173,6 +199,8 @@ import { Locale } from './entities/locale.entity';
 import { RoleMetadata } from './entities/role-metadata.entity';
 import { SavedFilters } from './entities/saved-filters.entity';
 import { ScheduledJob } from './entities/scheduled-job.entity';
+import { AgentSession } from './entities/agent-session.entity';
+import { AgentEvent } from './entities/agent-event.entity';
 import { SecurityRule } from './entities/security-rule.entity';
 import { Setting } from './entities/setting.entity';
 import { UserActivityHistory } from './entities/user-activity-history.entity';
@@ -203,22 +231,22 @@ import { IngestCommand } from './commands/ingest.command';
 import { MailFactory } from './factories/mail.factory';
 import { ErrorMapperService } from './helpers/error-mapper.service';
 import { SolidCoreErrorCodesProvider } from './helpers/solid-core-error-codes-provider.service';
-import { ComputedFieldEvaluationPublisherRabbitmq } from './jobs/computed-field-evaluation-publisher.service';
-import { ComputedFieldEvaluationSubscriberRabbitmq } from './jobs/computed-field-evaluation-subscriber.service';
+import { ComputedFieldEvaluationPublisherRabbitmq } from './jobs/rabbitmq/computed-field-evaluation-publisher.service';
+import { ComputedFieldEvaluationSubscriberRabbitmq } from './jobs/rabbitmq/computed-field-evaluation-subscriber.service';
 import { Msg91WhatsappQueuePublisherDatabase } from './jobs/database/msg91-whatsapp-publisher-database.service';
 import { Msg91WhatsappQueueSubscriberDatabase } from './jobs/database/msg91-whatsapp-subscriber-database.service';
 import { Three60WhatsappQueuePublisherDatabase } from './jobs/database/three60-whatsapp-publisher-database.service';
 import { Three60WhatsappQueueSubscriberDatabase } from './jobs/database/three60-whatsapp-subscriber-database.service';
 import { TriggerMcpClientPublisherDatabase } from './jobs/database/trigger-mcp-client-publisher-database.service';
 import { TriggerMcpClientSubscriberDatabase } from './jobs/database/trigger-mcp-client-subscriber-database.service';
-import { GenerateCodePublisherRabbitmq } from './jobs/generate-code-publisher.service';
-import { GenerateCodeSubscriberRabbitmq } from './jobs/generate-code-subscriber.service';
-import { Three60WhatsappQueuePublisher } from './jobs/three60-whatsapp-publisher.service';
-import { Three60WhatsappQueueSubscriber } from './jobs/three60-whatsapp-subscriber.service';
-import { TriggerMcpClientPublisherRabbitmq } from './jobs/trigger-mcp-client-publisher.service';
-import { TriggerMcpClientSubscriberRabbitmq } from './jobs/trigger-mcp-client-subscriber.service';
-import { TwilioSmsQueuePublisherRabbitmq } from './jobs/twilio-sms-publisher.service';
-import { TwilioSmsQueueSubscriberRabbitmq } from './jobs/twilio-sms-subscriber.service';
+import { GenerateCodePublisherRabbitmq } from './jobs/rabbitmq/generate-code-publisher.service';
+import { GenerateCodeSubscriberRabbitmq } from './jobs/rabbitmq/generate-code-subscriber.service';
+import { Three60WhatsappQueuePublisher } from './jobs/rabbitmq/three60-whatsapp-publisher.service';
+import { Three60WhatsappQueueSubscriber } from './jobs/rabbitmq/three60-whatsapp-subscriber.service';
+import { TriggerMcpClientPublisherRabbitmq } from './jobs/rabbitmq/trigger-mcp-client-publisher.service';
+import { TriggerMcpClientSubscriberRabbitmq } from './jobs/rabbitmq/trigger-mcp-client-subscriber.service';
+import { TwilioSmsQueuePublisherRabbitmq } from './jobs/rabbitmq/twilio-sms-publisher.service';
+import { TwilioSmsQueueSubscriberRabbitmq } from './jobs/rabbitmq/twilio-sms-subscriber.service';
 import { DashboardMapper } from './mappers/dashboard-mapper';
 import { ListOfValuesMapper } from './mappers/list-of-values-mapper';
 import { ActionMetadataRepository } from './repository/action-metadata.repository';
@@ -249,6 +277,8 @@ import { PermissionMetadataRepository } from './repository/permission-metadata.r
 import { RoleMetadataRepository } from './repository/role-metadata.repository';
 import { SavedFiltersRepository } from './repository/saved-filters.repository';
 import { ScheduledJobRepository } from './repository/scheduled-job.repository';
+import { AgentSessionRepository } from './repository/agent-session.repository';
+import { AgentEventRepository } from './repository/agent-event.repository';
 import { SecurityRuleRepository } from './repository/security-rule.repository';
 import { SettingRepository } from './repository/setting.repository';
 import { SmsTemplateRepository } from './repository/sms-template.repository';
@@ -295,6 +325,8 @@ import { RequestContextService } from './services/request-context.service';
 import { RoleMetadataService } from './services/role-metadata.service';
 import { SavedFiltersService } from './services/saved-filters.service';
 import { ScheduledJobService } from './services/scheduled-job.service';
+import { AgentSessionService } from './services/agent-session.service';
+import { AgentEventService } from './services/agent-event.service';
 import { SchedulerServiceImpl } from './services/scheduled-jobs/scheduler.service';
 import { SecurityRuleService } from './services/security-rule.service';
 import { ListOfDashboardQuestionProvidersSelectionProvider } from './services/selection-providers/list-of-dashboard-question-providers-selection-provider.service';
@@ -377,6 +409,8 @@ import { Entity } from 'typeorm';
       RoleMetadata,
       SavedFilters,
       ScheduledJob,
+      AgentSession,
+      AgentEvent,
       SecurityRule,
       Setting,
       SmsTemplate,
@@ -450,6 +484,8 @@ import { Entity } from 'typeorm';
     RoleMetadataController,
     SavedFiltersController,
     ScheduledJobController,
+    AgentSessionController,
+    AgentEventController,
     SecurityRuleController,
     ServiceController,
     SettingController,
@@ -606,6 +642,30 @@ import { Entity } from 'typeorm';
 
     TestQueuePublisherDatabase,
     TestQueueSubscriberDatabase,
+    TestQueuePublisherRedis,
+    TestQueueSubscriberRedis,
+    ApiEmailQueuePublisherRedis,
+    ApiEmailQueueSubscriberRedis,
+    ChatterQueuePublisherRedis,
+    ChatterQueueSubscriberRedis,
+    ComputedFieldEvaluationPublisherRedis,
+    ComputedFieldEvaluationSubscriberRedis,
+    GenerateCodePublisherRedis,
+    GenerateCodeSubscriberRedis,
+    Msg91OTPQueuePublisherRedis,
+    Msg91OTPQueueSubscriberRedis,
+    Msg91SmsQueuePublisherRedis,
+    Msg91SmsQueueSubscriberRedis,
+    Msg91WhatsappQueuePublisherRedis,
+    Msg91WhatsappQueueSubscriberRedis,
+    SmtpEmailQueuePublisherRedis,
+    SmtpEmailQueueSubscriberRedis,
+    Three60WhatsappQueuePublisherRedis,
+    Three60WhatsappQueueSubscriberRedis,
+    TriggerMcpClientPublisherRedis,
+    TriggerMcpClientSubscriberRedis,
+    TwilioSmsQueuePublisherRedis,
+    TwilioSmsQueueSubscriberRedis,
     GenerateCodePublisherDatabase,
     GenerateCodeSubscriberDatabase,
     GenerateCodePublisherRabbitmq,
@@ -687,6 +747,10 @@ import { Entity } from 'typeorm';
 
     ViewMetadataRepository,
     ScheduledJobRepository,
+    AgentSessionRepository,
+    AgentEventRepository,
+    AgentSessionService,
+    AgentEventService,
     ScheduledJobSubscriber,
     AlphaNumExternalIdComputationProvider,
     ListOfValuesSubscriber,

package/src/subscribers/audit.subscriber.ts

@@ -2,7 +2,7 @@ import { Injectable, Logger, Scope } from '@nestjs/common';
 import { lowerFirst } from 'src/helpers/string.helper';
 import { SolidRegistry } from 'src/helpers/solid-registry';
 import { DataSource, EntityMetadata, EntitySubscriberInterface, InsertEvent, RemoveEvent, UpdateEvent } from 'typeorm';
-import { AuditQueuePayload } from 'src/jobs/chatter-queue-publisher.service';
+import { AuditQueuePayload } from 'src/jobs/rabbitmq/chatter-queue-publisher.service';
 import { RequestContextService } from 'src/services/request-context.service';
 import { PublisherFactory } from 'src/services/queues/publisher-factory.service';
 

package/dist/jobs/api-email-publisher.service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-email-publisher.service.d.ts","sourceRoot":"","sources":["../../src/jobs/api-email-publisher.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AAEnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,qBACa,sBAAuB,SAAQ,iBAAiB,CAAC,GAAG,CAAC;IAE1D,SAAS,CAAC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB;IACrD,SAAS,CAAC,QAAQ,CAAC,qBAAqB,EAAE,qBAAqB;gBAD5C,gBAAgB,EAAE,gBAAgB,EAClC,qBAAqB,EAAE,qBAAqB;IAKnE,OAAO,IAAI,mBAAmB;CAKjC"}

package/dist/jobs/api-email-publisher.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-email-publisher.service.js","sourceRoot":"","sources":["../../src/jobs/api-email-publisher.service.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAA4C;AAE5C,8FAAmF;AACnF,wFAAyD;AACzD,mFAA8E;AAC9E,uEAAmE;AAI5D,IAAM,sBAAsB,GAA5B,MAAM,sBAAuB,SAAQ,8CAAsB;IAC9D,YACuB,gBAAkC,EAClC,qBAA4C;QAE/D,KAAK,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAAC;QAH5B,qBAAgB,GAAhB,gBAAgB,CAAkB;QAClC,0BAAqB,GAArB,qBAAqB,CAAuB;IAGnE,CAAC;IAED,OAAO;QACH,OAAO;YACH,GAAG,iCAAgB;SACtB,CAAA;IACL,CAAC;CACJ,CAAA;AAbY,wDAAsB;iCAAtB,sBAAsB;IADlC,IAAA,mBAAU,GAAE;qCAGgC,qCAAgB;QACX,gDAAqB;GAH1D,sBAAsB,CAalC","sourcesContent":["import { Injectable } from '@nestjs/common';\n\nimport { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';\nimport mailQueueOptions from './api-email-queue-options';\nimport { MqMessageQueueService } from 'src/services/mq-message-queue.service';\nimport { MqMessageService } from 'src/services/mq-message.service';\nimport { QueuesModuleOptions } from \"../interfaces\";\n\n@Injectable()\nexport class ApiEmailQueuePublisher extends RabbitMqPublisher<any> {\n    constructor(\n        protected readonly mqMessageService: MqMessageService,\n        protected readonly mqMessageQueueService: MqMessageQueueService,\n    ) {\n        super(mqMessageService, mqMessageQueueService);\n    }\n\n    options(): QueuesModuleOptions {\n        return {\n            ...mailQueueOptions\n        }\n    }\n}\n"]}

package/dist/jobs/api-email-queue-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-email-queue-options.d.ts","sourceRoot":"","sources":["../../src/jobs/api-email-queue-options.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;;;;;;AAI3C,wBAIE"}