@memberjunction/server 2.93.0 → 2.95.0

package/dist/resolvers/AskSkipResolver.js

@@ -22,7 +22,7 @@ import { LoadDataContextItemsServer } from '@memberjunction/data-context-server'
 import { LearningCycleScheduler } from '../scheduler/LearningCycleScheduler.js';
 LoadDataContextItemsServer();
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
-import { apiKey, baseUrl, configInfo, graphqlPort } from '../config.js';
+import { apiKey, baseUrl, publicUrl, configInfo, graphqlPort, graphqlRootPath } from '../config.js';
 import mssql from 'mssql';
 import { registerEnumType } from 'type-graphql';
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
@@ -31,6 +31,109 @@ import { GetAIAPIKey } from '@memberjunction/ai';
 import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes.js';
 import { AIEngine } from '@memberjunction/aiengine';
 import { deleteAccessToken, registerAccessToken, tokenExists } from './GetDataResolver.js';
+class ActiveConversationStreams {
+    static instance;
+    streams = new Map();
+    constructor() { }
+    static getInstance() {
+        if (!ActiveConversationStreams.instance) {
+            ActiveConversationStreams.instance = new ActiveConversationStreams();
+        }
+        return ActiveConversationStreams.instance;
+    }
+    updateStatus(conversationId, status, sessionId) {
+        const existing = this.streams.get(conversationId);
+        if (existing) {
+            existing.lastStatus = status;
+            existing.lastUpdate = new Date();
+            if (sessionId) {
+                existing.sessionIds.add(sessionId);
+            }
+        }
+        else {
+            const now = new Date();
+            this.streams.set(conversationId, {
+                lastStatus: status,
+                lastUpdate: now,
+                startTime: now,
+                sessionIds: sessionId ? new Set([sessionId]) : new Set()
+            });
+        }
+    }
+    getStatus(conversationId) {
+        const stream = this.streams.get(conversationId);
+        return stream ? stream.lastStatus : null;
+    }
+    getStartTime(conversationId) {
+        const stream = this.streams.get(conversationId);
+        return stream ? stream.startTime : null;
+    }
+    addSession(conversationId, sessionId) {
+        const stream = this.streams.get(conversationId);
+        if (stream) {
+            stream.sessionIds.add(sessionId);
+        }
+        else {
+            const now = new Date();
+            this.streams.set(conversationId, {
+                lastStatus: 'Processing...',
+                lastUpdate: now,
+                startTime: now,
+                sessionIds: new Set([sessionId])
+            });
+        }
+    }
+    removeConversation(conversationId) {
+        this.streams.delete(conversationId);
+    }
+    isActive(conversationId) {
+        const stream = this.streams.get(conversationId);
+        if (!stream)
+            return false;
+        const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000);
+        return stream.lastUpdate > fiveMinutesAgo;
+    }
+    getSessionIds(conversationId) {
+        const stream = this.streams.get(conversationId);
+        return stream ? Array.from(stream.sessionIds) : [];
+    }
+    cleanupStaleStreams() {
+        const now = new Date();
+        const staleThreshold = new Date(now.getTime() - 30 * 60 * 1000);
+        const staleConversations = [];
+        this.streams.forEach((stream, conversationId) => {
+            if (stream.lastUpdate < staleThreshold) {
+                staleConversations.push(conversationId);
+            }
+        });
+        staleConversations.forEach(conversationId => {
+            this.streams.delete(conversationId);
+            LogStatus(`Cleaned up stale stream for conversation ${conversationId}`);
+        });
+        if (staleConversations.length > 0) {
+            LogStatus(`Cleaned up ${staleConversations.length} stale conversation streams`);
+        }
+    }
+}
+const activeStreams = ActiveConversationStreams.getInstance();
+setInterval(() => {
+    activeStreams.cleanupStaleStreams();
+}, 10 * 60 * 1000);
+let ReattachConversationResponse = class ReattachConversationResponse {
+    lastStatusMessage;
+    startTime;
+};
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], ReattachConversationResponse.prototype, "lastStatusMessage", void 0);
+__decorate([
+    Field(() => Date, { nullable: true }),
+    __metadata("design:type", Date)
+], ReattachConversationResponse.prototype, "startTime", void 0);
+ReattachConversationResponse = __decorate([
+    ObjectType()
+], ReattachConversationResponse);
 var SkipResponsePhase;
 (function (SkipResponsePhase) {
     SkipResponsePhase["ClarifyingQuestion"] = "clarifying_question";
@@ -587,7 +690,7 @@ cycle.`);
             organizationID: skipConfigInfo.orgID,
             organizationInfo: configInfo?.askSkip?.organizationInfo,
             apiKeys: this.buildSkipAPIKeys(),
-            callingServerURL: accessToken ? `${baseUrl}:${graphqlPort}` : undefined,
+            callingServerURL: accessToken ? (publicUrl || `${baseUrl}:${graphqlPort}${graphqlRootPath}`) : undefined,
             callingServerAPIKey: accessToken ? apiKey : undefined,
             callingServerAccessToken: accessToken ? accessToken.Token : undefined
         };
@@ -812,6 +915,80 @@ cycle.`);
             },
         ];
     }
+    async ReattachToProcessingConversation(ConversationId, { userPayload }, pubSub) {
+        try {
+            const md = new Metadata();
+            const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+            if (!user) {
+                LogError(`User ${userPayload.email} not found in UserCache`);
+                return null;
+            }
+            const convoEntity = await md.GetEntityObject('Conversations', user);
+            const loadResult = await convoEntity.Load(ConversationId);
+            if (!loadResult) {
+                LogError(`Could not load conversation ${ConversationId} for re-attachment`);
+                return null;
+            }
+            if (convoEntity.UserID !== user.ID) {
+                LogError(`Conversation ${ConversationId} does not belong to user ${user.Email}`);
+                return null;
+            }
+            if (convoEntity.Status === 'Processing') {
+                activeStreams.addSession(ConversationId, userPayload.sessionId);
+                const lastStatusMessage = activeStreams.getStatus(ConversationId) || 'Processing...';
+                const startTime = activeStreams.getStartTime(ConversationId);
+                const isStreamActive = activeStreams.isActive(ConversationId);
+                if (isStreamActive) {
+                    const statusMessage = {
+                        type: 'AskSkip',
+                        status: 'OK',
+                        ResponsePhase: 'Processing',
+                        conversationID: convoEntity.ID,
+                        message: lastStatusMessage,
+                    };
+                    pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                        pushStatusUpdates: {
+                            message: JSON.stringify(statusMessage),
+                            sessionId: userPayload.sessionId
+                        }
+                    });
+                    LogStatus(`Re-attached session ${userPayload.sessionId} to active stream for conversation ${ConversationId}, last status: ${lastStatusMessage}`);
+                    return {
+                        lastStatusMessage,
+                        startTime: startTime || convoEntity.__mj_UpdatedAt
+                    };
+                }
+                else {
+                    const statusMessage = {
+                        type: 'AskSkip',
+                        status: 'OK',
+                        ResponsePhase: 'Processing',
+                        conversationID: convoEntity.ID,
+                        message: 'Processing...',
+                    };
+                    pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                        pushStatusUpdates: {
+                            message: JSON.stringify(statusMessage),
+                            sessionId: userPayload.sessionId
+                        }
+                    });
+                    LogStatus(`Re-attached session ${userPayload.sessionId} to conversation ${ConversationId}, but stream is inactive`);
+                    return {
+                        lastStatusMessage: 'Processing...',
+                        startTime: convoEntity.__mj_UpdatedAt
+                    };
+                }
+            }
+            else {
+                LogStatus(`Conversation ${ConversationId} is not processing (Status: ${convoEntity.Status})`);
+                return null;
+            }
+        }
+        catch (error) {
+            LogError(`Error re-attaching to conversation: ${error}`);
+            return null;
+        }
+    }
     async ExecuteAskSkipAnalysisQuery(UserQuestion, ConversationId, { dataSource, userPayload }, pubSub, DataContextId, ForceEntityRefresh, StartTime) {
         const md = new Metadata();
         const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
@@ -819,7 +996,7 @@ cycle.`);
             throw new Error(`User ${userPayload.email} not found in UserCache`);
         const requestStartTime = StartTime || new Date();
         const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipChatInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId);
-        await this.setConversationStatus(convoEntity, 'Processing', userPayload);
+        await this.setConversationStatus(convoEntity, 'Processing', userPayload, pubSub);
         const messages = await this.LoadConversationDetailsIntoSkipMessages(dataSource, convoEntity.ID, AskSkipResolver_1._maxHistoricalMessages);
         const conversationDetailCount = 1;
         const input = await this.buildSkipChatAPIRequest(messages, ConversationId, dataContext, 'initial_request', true, true, true, false, user, dataSource, ForceEntityRefresh === undefined ? false : ForceEntityRefresh, true);
@@ -1375,7 +1552,7 @@ cycle.`);
         const skipConfigInfo = configInfo.askSkip;
         LogStatus(`   >>> HandleSkipRequest: Sending request to Skip API: ${skipConfigInfo.chatURL}`);
         if (conversationDetailCount > 10) {
-            await this.setConversationStatus(convoEntity, 'Available', userPayload);
+            await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
             pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
                 message: JSON.stringify({
                     type: 'AskSkip',
@@ -1400,21 +1577,26 @@ cycle.`);
             response = await sendPostRequest(skipConfigInfo.chatURL, input, true, null, (message) => {
                 LogStatus(JSON.stringify(message, null, 4));
                 if (message.type === 'status_update') {
-                    pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
-                        message: JSON.stringify({
-                            type: 'AskSkip',
-                            status: 'OK',
-                            conversationID: ConversationId,
-                            ResponsePhase: message.value.responsePhase,
-                            message: message.value.messages[0].content,
-                        }),
-                        sessionId: userPayload.sessionId,
-                    });
+                    const statusContent = message.value.messages[0].content;
+                    activeStreams.updateStatus(ConversationId, statusContent, userPayload.sessionId);
+                    const sessionIds = activeStreams.getSessionIds(ConversationId);
+                    for (const sessionId of sessionIds) {
+                        pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                            message: JSON.stringify({
+                                type: 'AskSkip',
+                                status: 'OK',
+                                conversationID: ConversationId,
+                                ResponsePhase: message.value.responsePhase,
+                                message: statusContent,
+                            }),
+                            sessionId: sessionId,
+                        });
+                    }
                 }
             });
         }
         catch (error) {
-            await this.setConversationStatus(convoEntity, 'Available', userPayload);
+            await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
             LogError(`Error in HandleSkipChatRequest sendPostRequest: ${error}`);
             pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
                 message: JSON.stringify({
@@ -1445,7 +1627,7 @@ cycle.`);
             }
         }
         else {
-            await this.setConversationStatus(convoEntity, 'Available', userPayload);
+            await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
             pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
                 message: JSON.stringify({
                     type: 'AskSkip',
@@ -1515,7 +1697,7 @@ cycle.`);
         convoDetailEntityAI.Role = 'AI';
         convoDetailEntityAI.HiddenToUser = false;
         convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
-        await this.setConversationStatus(convoEntity, 'Available', userPayload);
+        await this.setConversationStatus(convoEntity, 'Available', userPayload, pubSub);
         if (await convoDetailEntityAI.Save()) {
             return {
                 Success: true,
@@ -1782,13 +1964,38 @@ cycle.`);
             AIMessageConversationDetailID: convoDetailEntityAI.ID,
         };
     }
-    async setConversationStatus(convoEntity, status, userPayload) {
+    async setConversationStatus(convoEntity, status, userPayload, pubSub) {
         if (convoEntity.Status !== status) {
             convoEntity.Status = status;
             const convoSaveResult = await convoEntity.Save();
             if (!convoSaveResult) {
                 LogError(`Error updating conversation status to '${status}'`, undefined, convoEntity.LatestResult);
             }
+            else {
+                if (status === 'Available') {
+                    activeStreams.removeConversation(convoEntity.ID);
+                    LogStatus(`Removed conversation ${convoEntity.ID} from active streams (status changed to Available)`);
+                }
+                else if (status === 'Processing') {
+                    activeStreams.addSession(convoEntity.ID, userPayload.sessionId);
+                    LogStatus(`Added session ${userPayload.sessionId} to active streams for conversation ${convoEntity.ID}`);
+                }
+                if (pubSub) {
+                    const statusMessage = {
+                        type: 'ConversationStatusUpdate',
+                        conversationID: convoEntity.ID,
+                        status: status,
+                        timestamp: new Date().toISOString()
+                    };
+                    pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                        pushStatusUpdates: {
+                            message: JSON.stringify(statusMessage),
+                            sessionId: userPayload.sessionId
+                        }
+                    });
+                    LogStatus(`Published conversation status update for ${convoEntity.ID}: ${status}`);
+                }
+            }
             return convoSaveResult;
         }
         return true;
@@ -1943,6 +2150,15 @@ __decorate([
     __metadata("design:paramtypes", [Object, PubSubEngine, String, String]),
     __metadata("design:returntype", Promise)
 ], AskSkipResolver.prototype, "ExecuteAskSkipRunScript", null);
+__decorate([
+    Query(() => ReattachConversationResponse),
+    __param(0, Arg('ConversationId', () => String)),
+    __param(1, Ctx()),
+    __param(2, PubSub()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, PubSubEngine]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ReattachToProcessingConversation", null);
 __decorate([
     Query(() => AskSkipResultType),
     __param(0, Arg('UserQuestion', () => String)),