@memberjunction/server 2.35.1 → 2.36.1

package/dist/resolvers/AskSkipResolver.js

@@ -11,16 +11,18 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 var AskSkipResolver_1;
-import { Arg, Ctx, Field, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
+import { Arg, Ctx, Field, Mutation, ObjectType, PubSub, PubSubEngine, Query, Resolver } from 'type-graphql';
 import { LogError, LogStatus, Metadata, RunView, CompositeKey } from '@memberjunction/core';
+import { MJ_SERVER_EVENT_CODE } from '../types.js';
 import { BehaviorSubject } from 'rxjs';
 import { take } from 'rxjs/operators';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { DataContext } from '@memberjunction/data-context';
 import { LoadDataContextItemsServer } from '@memberjunction/data-context-server';
+import { LearningCycleScheduler } from '../scheduler/LearningCycleScheduler.js';
 LoadDataContextItemsServer();
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
-import { ___skipAPIOrgId, ___skipAPIurl, apiKey, baseUrl, configInfo, graphqlPort, mj_core_schema } from '../config.js';
+import { ___skipAPIOrgId, ___skipAPIurl, ___skipLearningAPIurl, ___skipLearningCycleIntervalInMinutes, apiKey, baseUrl, configInfo, graphqlPort, mj_core_schema } from '../config.js';
 import { registerEnumType } from 'type-graphql';
 import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
 import { sendPostRequest } from '../util.js';
@@ -79,9 +81,149 @@ AskSkipResultType = __decorate([
     ObjectType()
 ], AskSkipResultType);
 export { AskSkipResultType };
+let ManualLearningCycleResultType = class ManualLearningCycleResultType {
+    Success;
+    Message;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], ManualLearningCycleResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], ManualLearningCycleResultType.prototype, "Message", void 0);
+ManualLearningCycleResultType = __decorate([
+    ObjectType()
+], ManualLearningCycleResultType);
+export { ManualLearningCycleResultType };
+let CycleDetailsType = class CycleDetailsType {
+    LearningCycleId;
+    StartTime;
+    RunningForMinutes;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CycleDetailsType.prototype, "LearningCycleId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], CycleDetailsType.prototype, "StartTime", void 0);
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], CycleDetailsType.prototype, "RunningForMinutes", void 0);
+CycleDetailsType = __decorate([
+    ObjectType()
+], CycleDetailsType);
+export { CycleDetailsType };
+let RunningOrganizationType = class RunningOrganizationType {
+    OrganizationId;
+    LearningCycleId;
+    StartTime;
+    RunningForMinutes;
+};
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], RunningOrganizationType.prototype, "OrganizationId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], RunningOrganizationType.prototype, "LearningCycleId", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], RunningOrganizationType.prototype, "StartTime", void 0);
+__decorate([
+    Field(() => Number),
+    __metadata("design:type", Number)
+], RunningOrganizationType.prototype, "RunningForMinutes", void 0);
+RunningOrganizationType = __decorate([
+    ObjectType()
+], RunningOrganizationType);
+export { RunningOrganizationType };
+let LearningCycleStatusType = class LearningCycleStatusType {
+    IsSchedulerRunning;
+    LastRunTime;
+    RunningOrganizations;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], LearningCycleStatusType.prototype, "IsSchedulerRunning", void 0);
+__decorate([
+    Field(() => String, { nullable: true }),
+    __metadata("design:type", String)
+], LearningCycleStatusType.prototype, "LastRunTime", void 0);
+__decorate([
+    Field(() => [RunningOrganizationType], { nullable: true }),
+    __metadata("design:type", Array)
+], LearningCycleStatusType.prototype, "RunningOrganizations", void 0);
+LearningCycleStatusType = __decorate([
+    ObjectType()
+], LearningCycleStatusType);
+export { LearningCycleStatusType };
+let StopLearningCycleResultType = class StopLearningCycleResultType {
+    Success;
+    Message;
+    WasRunning;
+    CycleDetails;
+};
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], StopLearningCycleResultType.prototype, "Success", void 0);
+__decorate([
+    Field(() => String),
+    __metadata("design:type", String)
+], StopLearningCycleResultType.prototype, "Message", void 0);
+__decorate([
+    Field(() => Boolean),
+    __metadata("design:type", Boolean)
+], StopLearningCycleResultType.prototype, "WasRunning", void 0);
+__decorate([
+    Field(() => CycleDetailsType, { nullable: true }),
+    __metadata("design:type", CycleDetailsType)
+], StopLearningCycleResultType.prototype, "CycleDetails", void 0);
+StopLearningCycleResultType = __decorate([
+    ObjectType()
+], StopLearningCycleResultType);
+export { StopLearningCycleResultType };
 let AskSkipResolver = class AskSkipResolver {
     static { AskSkipResolver_1 = this; }
     static _defaultNewChatName = 'New Chat';
+    static {
+        try {
+            LogStatus('Initializing Skip AI Learning Cycle Scheduler');
+            const eventListener = MJGlobal.Instance.GetEventListener(true);
+            eventListener.subscribe(event => {
+                if (event.eventCode === MJ_SERVER_EVENT_CODE && event.args?.type === 'setupComplete') {
+                    try {
+                        const dataSources = event.args.dataSources;
+                        if (dataSources && dataSources.length > 0) {
+                            const scheduler = LearningCycleScheduler.Instance;
+                            scheduler.setDataSources(dataSources);
+                            const interval = ___skipLearningCycleIntervalInMinutes ?? 60;
+                            scheduler.start(interval);
+                            LogStatus(`📅 Skip AI Learning cycle scheduler started with ${interval} minute interval`);
+                        }
+                        else {
+                            LogError('Cannot initialize Skip learning cycle scheduler: No data sources available');
+                        }
+                    }
+                    catch (error) {
+                        LogError(`Error initializing Skip learning cycle scheduler: ${error}`);
+                    }
+                }
+            });
+            LogStatus('Skip AI Learning Cycle Scheduler initialization listener registered');
+        }
+        catch (error) {
+            LogError(`Failed to initialize Skip learning cycle scheduler: ${error}`);
+        }
+    }
     static _maxHistoricalMessages = 30;
     async ExecuteAskSkipRecordChat(UserQuestion, ConversationId, EntityName, compositeKey, { dataSource, userPayload }, pubSub) {
         const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
@@ -92,7 +234,7 @@ let AskSkipResolver = class AskSkipResolver {
             messages = await this.LoadConversationDetailsIntoSkipMessages(dataSource, ConversationId, AskSkipResolver_1._maxHistoricalMessages);
         }
         const md = new Metadata();
-        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, null);
+        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipChatInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, null);
         if (!ConversationId || ConversationId.length === 0) {
             const dci = await md.GetEntityObject('Data Context Items', user);
             dci.DataContextID = dataContext.ID;
@@ -115,16 +257,105 @@ let AskSkipResolver = class AskSkipResolver {
                 LogError(`Error saving ConversationEntity for record chat: ${EntityName} ${ck.Values()}`, undefined, convoEntity.LatestResult);
             }
         }
-        const input = await this.buildSkipAPIRequest(messages, ConversationId, dataContext, 'chat_with_a_record', false, false, false, user, dataSource, false, false);
+        const input = await this.buildSkipChatAPIRequest(messages, ConversationId, dataContext, 'chat_with_a_record', false, false, false, false, user, dataSource, false, false);
         messages.push({
             content: UserQuestion,
             role: 'user',
             conversationDetailID: convoDetailEntity.ID,
         });
-        return this.handleSimpleSkipPostRequest(input, convoEntity.ID, convoDetailEntity.ID, true, user);
+        return this.handleSimpleSkipChatPostRequest(input, convoEntity.ID, convoDetailEntity.ID, true, user);
+    }
+    async ExecuteAskSkipLearningCycle({ dataSource, userPayload }, ForceEntityRefresh) {
+        const startTime = new Date();
+        const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
+        if (!user)
+            throw new Error(`User ${userPayload.email} not found in UserCache`);
+        await AIEngine.Instance.Config(false, user);
+        const organizationId = ___skipAPIOrgId;
+        const scheduler = LearningCycleScheduler.Instance;
+        const runningStatus = scheduler.isOrganizationRunningCycle(organizationId);
+        if (runningStatus.isRunning) {
+            LogStatus(`Learning cycle already in progress for organization ${organizationId}, started at ${runningStatus.startTime.toISOString()}`);
+            return {
+                success: false,
+                error: `Learning cycle already in progress for this organization (started ${Math.round(runningStatus.runningForMinutes)} minutes ago)`,
+                elapsedTime: 0,
+                noteChanges: [],
+                queryChanges: [],
+                requestChanges: []
+            };
+        }
+        LogStatus(`Starting learning cycle for AI agent Skip`);
+        const md = new Metadata();
+        const skipAgent = AIEngine.Instance.GetAgentByName('Skip');
+        if (!skipAgent) {
+            throw new Error("Skip agent not found in AIEngine");
+        }
+        const agentID = skipAgent.ID;
+        const lastCompleteLearningCycleDate = await this.GetLastCompleteLearningCycleDate(agentID, user);
+        const learningCycleEntity = await md.GetEntityObject('AI Agent Learning Cycles', user);
+        learningCycleEntity.NewRecord();
+        learningCycleEntity.AgentID = skipAgent.ID;
+        learningCycleEntity.Status = 'In-Progress';
+        learningCycleEntity.StartedAt = startTime;
+        if (!(await learningCycleEntity.Save())) {
+            throw new Error(`Failed to create learning cycle record: ${learningCycleEntity.LatestResult.Error}`);
+        }
+        const learningCycleId = learningCycleEntity.ID;
+        LogStatus(`Created new learning cycle with ID: ${learningCycleId}`);
+        scheduler.registerRunningCycle(organizationId, learningCycleId);
+        try {
+            LogStatus(`Building Skip Learning API request`);
+            const input = await this.buildSkipLearningAPIRequest(learningCycleId, lastCompleteLearningCycleDate, true, true, true, true, dataSource, user, ForceEntityRefresh || false);
+            const response = await this.handleSimpleSkipLearningPostRequest(input, user, learningCycleId, agentID);
+            const endTime = new Date();
+            const elapsedTimeMs = endTime.getTime() - startTime.getTime();
+            LogStatus(`Learning cycle finished with status: ${response.success ? 'Success' : 'Failed'} in ${elapsedTimeMs / 1000} seconds`);
+            learningCycleEntity.Status = response.success ? 'Complete' : 'Failed';
+            learningCycleEntity.EndedAt = endTime;
+            if (!(await learningCycleEntity.Save())) {
+                LogError(`Failed to update learning cycle record: ${learningCycleEntity.LatestResult.Error}`);
+            }
+            scheduler.unregisterRunningCycle(organizationId);
+            return response;
+        }
+        catch (error) {
+            learningCycleEntity.Status = 'Failed';
+            learningCycleEntity.EndedAt = new Date();
+            try {
+                await learningCycleEntity.Save();
+            }
+            catch (saveError) {
+                LogError(`Failed to update learning cycle record after error: ${saveError}`);
+            }
+            scheduler.unregisterRunningCycle(organizationId);
+            throw error;
+        }
+    }
+    async handleSimpleSkipLearningPostRequest(input, user, learningCycleId, agentID) {
+        LogStatus(`   >>> HandleSimpleSkipLearningPostRequest Sending request to Skip API: ${___skipLearningAPIurl}`);
+        const response = await sendPostRequest(___skipLearningAPIurl, input, true, null);
+        if (response && response.length > 0) {
+            const apiResponse = response[response.length - 1].value;
+            LogStatus(`  Skip API response: ${apiResponse.success}`);
+            if (apiResponse.noteChanges && apiResponse.noteChanges.length > 0) {
+                await this.processLearningCycleNoteChanges(apiResponse.noteChanges, agentID, user);
+            }
+            return apiResponse;
+        }
+        else {
+            return {
+                success: false,
+                error: 'Error',
+                elapsedTime: 0,
+                noteChanges: [],
+                queryChanges: [],
+                requestChanges: [],
+            };
+        }
     }
-    async handleSimpleSkipPostRequest(input, conversationID = '', UserMessageConversationDetailId = '', createAIMessageConversationDetail = false, user = null) {
-        LogStatus(`   >>> HandleSimpleSkipPostRequest Sending request to Skip API: ${___skipAPIurl}`);
+    async handleSimpleSkipChatPostRequest(input, conversationID = '', UserMessageConversationDetailId = '', createAIMessageConversationDetail = false, user = null) {
+        LogStatus(`   >>> HandleSimpleSkipChatPostRequest Sending request to Skip API: ${___skipAPIurl}`);
         const response = await sendPostRequest(___skipAPIurl, input, true, null);
         if (response && response.length > 0) {
             const apiResponse = response[response.length - 1].value;
@@ -154,6 +385,85 @@ let AskSkipResolver = class AskSkipResolver {
             };
         }
     }
+    async processLearningCycleNoteChanges(noteChanges, agentID, user) {
+        const md = new Metadata();
+        const validNoteChanges = noteChanges.filter(change => {
+            if (change.note.agentNoteType === "Human") {
+                LogStatus(`WARNING: Ignoring ${change.changeType} operation on Human note with ID ${change.note.id}. Human notes cannot be modified by the
+    learning cycle.`);
+                return false;
+            }
+            return true;
+        });
+        await Promise.all(validNoteChanges.map(async (change) => {
+            try {
+                if (change.changeType === 'add' || change.changeType === 'update') {
+                    await this.processAddOrUpdateSkipNote(change, agentID, user);
+                }
+                else if (change.changeType === 'delete') {
+                    await this.processDeleteSkipNote(change, user);
+                }
+            }
+            catch (e) {
+                LogError(`Error processing note change: ${e}`);
+            }
+        }));
+    }
+    async processAddOrUpdateSkipNote(change, agentID, user) {
+        try {
+            const md = new Metadata();
+            const noteEntity = await md.GetEntityObject('AI Agent Notes', user);
+            if (change.changeType === 'update') {
+                const loadResult = await noteEntity.Load(change.note.id);
+                if (!loadResult) {
+                    LogError(`Could not load note with ID ${change.note.id}`);
+                    return false;
+                }
+            }
+            else {
+                if (change.note.agentNoteType === "Human") {
+                    LogStatus(`WARNING: Cannot create a new Human note with the learning cycle. Operation ignored.`);
+                    return false;
+                }
+                noteEntity.NewRecord();
+                noteEntity.AgentID = agentID;
+            }
+            noteEntity.AgentNoteTypeID = this.getAgentNoteTypeIDByName('AI');
+            noteEntity.Note = change.note.note;
+            noteEntity.Type = change.note.type;
+            if (change.note.type === 'User') {
+                noteEntity.UserID = change.note.userId;
+            }
+            if (!(await noteEntity.Save())) {
+                LogError(`Error saving AI Agent Note: ${noteEntity.LatestResult.Error}`);
+                return false;
+            }
+            return true;
+        }
+        catch (e) {
+            LogError(`Error processing note change: ${e}`);
+            return false;
+        }
+    }
+    async processDeleteSkipNote(change, user) {
+        const md = new Metadata();
+        const noteEntity = await md.GetEntityObject('AI Agent Notes', user);
+        const loadResult = await noteEntity.Load(change.note.id);
+        if (!loadResult) {
+            LogError(`Could not load note with ID ${change.note.id} for deletion`);
+            return false;
+        }
+        if (change.note.agentNoteType === "Human") {
+            LogStatus(`WARNING: Ignoring delete operation on Human note with ID ${change.note.id}. Human notes cannot be deleted by the learning
+cycle.`);
+            return false;
+        }
+        if (!(await noteEntity.Delete())) {
+            LogError(`Error deleting AI Agent Note: ${noteEntity.LatestResult.Error}`);
+            return false;
+        }
+        return true;
+    }
     async CreateAIMessageConversationDetail(apiResponse, conversationID, user) {
         const md = new Metadata();
         const convoDetailEntityAI = await md.GetEntityObject('Conversation Details', user);
@@ -172,37 +482,151 @@ let AskSkipResolver = class AskSkipResolver {
             return '';
         }
     }
-    async buildSkipAPIRequest(messages, conversationId, dataContext, requestPhase, includeEntities, includeQueries, includeNotes, contextUser, dataSource, forceEntitiesRefresh = false, includeCallBackKeyAndAccessToken = false) {
+    async buildBaseSkipRequest(contextUser, dataSource, includeEntities, includeQueries, includeNotes, includeRequests, forceEntitiesRefresh = false, includeCallBackKeyAndAccessToken = false, additionalTokenInfo = {}) {
         const entities = includeEntities ? await this.BuildSkipEntities(dataSource, forceEntitiesRefresh) : [];
         const queries = includeQueries ? this.BuildSkipQueries() : [];
         const { notes, noteTypes } = includeNotes ? await this.BuildSkipAgentNotes(contextUser) : { notes: [], noteTypes: [] };
+        const requests = includeRequests ? await this.BuildSkipRequests(contextUser) : [];
         let accessToken;
         if (includeCallBackKeyAndAccessToken) {
-            accessToken = registerAccessToken(undefined, 1000 * 60 * 10, {
+            const tokenInfo = {
                 type: 'skip_api_request',
                 userEmail: contextUser.Email,
                 userName: contextUser.Name,
                 userID: contextUser.ID,
-                conversationId: conversationId,
-                requestPhase: requestPhase,
-            });
+                ...additionalTokenInfo
+            };
+            accessToken = registerAccessToken(undefined, 1000 * 60 * 10, tokenInfo);
         }
-        const input = {
-            apiKeys: this.buildSkipAPIKeys(),
+        return {
+            entities,
+            queries,
+            notes,
+            noteTypes,
+            requests,
+            accessToken,
+            organizationId: ___skipAPIOrgId,
             organizationInfo: configInfo?.askSkip?.organizationInfo,
-            messages: messages,
-            conversationID: conversationId.toString(),
-            dataContext: CopyScalarsAndArrays(dataContext),
-            organizationID: ___skipAPIOrgId,
-            requestPhase: requestPhase,
-            entities: entities,
-            queries: queries,
-            notes: notes,
-            noteTypes: noteTypes,
+            apiKeys: this.buildSkipAPIKeys(),
             callingServerURL: accessToken ? `${baseUrl}:${graphqlPort}` : undefined,
             callingServerAPIKey: accessToken ? apiKey : undefined,
             callingServerAccessToken: accessToken ? accessToken.Token : undefined
         };
+    }
+    async buildSkipLearningAPIRequest(learningCycleId, lastLearningCycleDate, includeEntities, includeQueries, includeNotes, includeRequests, dataSource, contextUser, forceEntitiesRefresh = false, includeCallBackKeyAndAccessToken = false) {
+        const baseRequest = await this.buildBaseSkipRequest(contextUser, dataSource, includeEntities, includeQueries, includeNotes, includeRequests, forceEntitiesRefresh, includeCallBackKeyAndAccessToken);
+        const newConversations = await this.BuildSkipLearningCycleNewConversations(lastLearningCycleDate, dataSource, contextUser);
+        const input = {
+            organizationId: baseRequest.organizationId,
+            organizationInfo: baseRequest.organizationInfo,
+            learningCycleId,
+            lastLearningCycleDate,
+            newConversations,
+            entities: baseRequest.entities,
+            queries: baseRequest.queries,
+            notes: baseRequest.notes,
+            noteTypes: baseRequest.noteTypes,
+            requests: baseRequest.requests,
+            apiKeys: baseRequest.apiKeys
+        };
+        return input;
+    }
+    async BuildSkipLearningCycleNewConversations(lastLearningCycleDate, dataSource, contextUser) {
+        try {
+            const rv = new RunView();
+            const conversationsSinceLastLearningCycle = await rv.RunView({
+                EntityName: 'Conversations',
+                ExtraFilter: `ID IN (SELECT ConversationID FROM __mj.vwConversationDetails WHERE __mj_UpdatedAt >= '${lastLearningCycleDate.toISOString()}')`,
+                ResultType: 'entity_object',
+            }, contextUser);
+            if (!conversationsSinceLastLearningCycle.Success || conversationsSinceLastLearningCycle.Results.length === 0) {
+                return [];
+            }
+            return await Promise.all(conversationsSinceLastLearningCycle.Results.map(async (c) => {
+                return {
+                    id: c.ID,
+                    name: c.Name,
+                    userId: c.UserID,
+                    user: c.User,
+                    description: c.Description,
+                    messages: await this.LoadConversationDetailsIntoSkipMessages(dataSource, c.ID),
+                    createdAt: c.__mj_CreatedAt,
+                    updatedAt: c.__mj_UpdatedAt
+                };
+            }));
+        }
+        catch (e) {
+            LogError(`Error loading conversations since last learning cycle: ${e}`);
+            return [];
+        }
+    }
+    async BuildSkipRequests(contextUser) {
+        try {
+            const md = new Metadata();
+            const requestEntity = await md.GetEntityObject('AI Agent Requests', contextUser);
+            const allRequests = await requestEntity.GetAll();
+            const requests = allRequests.map((r) => {
+                return {
+                    id: r.ID,
+                    agentId: r.AIAgentID,
+                    agnet: r.AIAgent,
+                    requestedAt: r.RequestedAt,
+                    requestForUserId: r.RequestedForUserID,
+                    requestForUser: r.RequestedForUser,
+                    status: r.Status,
+                    request: r.Request,
+                    response: r.Response,
+                    responseByUserId: r.ResponseByUserID,
+                    responseByUser: r.ResponseByUser,
+                    respondedAt: r.RespondedAt,
+                    comments: r.Comments,
+                    createdAt: r.__mj_CreatedAt,
+                    updatedAt: r.__mj_UpdatedAt,
+                };
+            });
+            return requests;
+        }
+        catch (e) {
+            LogError(`Error loading requests: ${e}`);
+            return [];
+        }
+    }
+    async GetLastCompleteLearningCycleDate(agentID, user) {
+        const md = new Metadata();
+        const rv = new RunView();
+        const lastLearningCycleRV = await rv.RunView({
+            EntityName: 'AI Agent Learning Cycles',
+            ExtraFilter: `AgentID = '${agentID}' AND Status = 'Complete'`,
+            ResultType: 'entity_object',
+            OrderBy: 'StartedAt DESC',
+            MaxRows: 1,
+        }, user);
+        const lastLearningCycle = lastLearningCycleRV.Results[0];
+        if (lastLearningCycle) {
+            return lastLearningCycle.StartedAt;
+        }
+        else {
+            return new Date(0);
+        }
+    }
+    async buildSkipChatAPIRequest(messages, conversationId, dataContext, requestPhase, includeEntities, includeQueries, includeNotes, includeRequests, contextUser, dataSource, forceEntitiesRefresh = false, includeCallBackKeyAndAccessToken = false) {
+        const additionalTokenInfo = {
+            conversationId,
+            requestPhase,
+        };
+        const baseRequest = await this.buildBaseSkipRequest(contextUser, dataSource, includeEntities, includeQueries, includeNotes, includeRequests, forceEntitiesRefresh, includeCallBackKeyAndAccessToken, additionalTokenInfo);
+        const input = {
+            messages,
+            conversationID: conversationId.toString(),
+            dataContext: CopyScalarsAndArrays(dataContext),
+            organizationID: baseRequest.organizationId,
+            requestPhase,
+            entities: baseRequest.entities,
+            queries: baseRequest.queries,
+            notes: baseRequest.notes,
+            noteTypes: baseRequest.noteTypes,
+            apiKeys: baseRequest.apiKeys,
+        };
         return input;
     }
     async ExecuteAskSkipRunScript({ dataSource, userPayload }, pubSub, DataContextId, ScriptText) {
@@ -211,9 +635,9 @@ let AskSkipResolver = class AskSkipResolver {
             throw new Error(`User ${userPayload.email} not found in UserCache`);
         const dataContext = new DataContext();
         await dataContext.Load(DataContextId, dataSource, true, false, 0, user);
-        const input = await this.buildSkipAPIRequest([], '', dataContext, 'run_existing_script', false, false, false, user, dataSource, false, false);
+        const input = await this.buildSkipChatAPIRequest([], '', dataContext, 'run_existing_script', false, false, false, false, user, dataSource, false, false);
         input.scriptText = ScriptText;
-        return this.handleSimpleSkipPostRequest(input);
+        return this.handleSimpleSkipChatPostRequest(input);
     }
     buildSkipAPIKeys() {
         return [
@@ -244,11 +668,11 @@ let AskSkipResolver = class AskSkipResolver {
         const user = UserCache.Instance.Users.find((u) => u.Email.trim().toLowerCase() === userPayload.email.trim().toLowerCase());
         if (!user)
             throw new Error(`User ${userPayload.email} not found in UserCache`);
-        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId);
+        const { convoEntity, dataContextEntity, convoDetailEntity, dataContext } = await this.HandleSkipChatInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId);
         const messages = await this.LoadConversationDetailsIntoSkipMessages(dataSource, convoEntity.ID, AskSkipResolver_1._maxHistoricalMessages);
         const conversationDetailCount = 1;
-        const input = await this.buildSkipAPIRequest(messages, ConversationId, dataContext, 'initial_request', true, true, true, user, dataSource, ForceEntityRefresh === undefined ? false : ForceEntityRefresh, true);
-        return this.HandleSkipRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount);
+        const input = await this.buildSkipChatAPIRequest(messages, ConversationId, dataContext, 'initial_request', true, true, true, false, user, dataSource, ForceEntityRefresh === undefined ? false : ForceEntityRefresh, true);
+        return this.HandleSkipChatRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount);
     }
     BuildSkipQueries(status = 'Approved') {
         const md = new Metadata();
@@ -565,7 +989,7 @@ let AskSkipResolver = class AskSkipResolver {
             return null;
         }
     }
-    async HandleSkipInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId) {
+    async HandleSkipChatInitialObjectLoading(dataSource, ConversationId, UserQuestion, user, userPayload, md, DataContextId) {
         const convoEntity = await md.GetEntityObject('Conversations', user);
         let dataContextEntity;
         if (!ConversationId || ConversationId.length === 0) {
@@ -747,7 +1171,7 @@ let AskSkipResolver = class AskSkipResolver {
                 return 'user';
         }
     }
-    async HandleSkipRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount) {
+    async HandleSkipChatRequest(input, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount) {
         LogStatus(`   >>> HandleSkipRequest: Sending request to Skip API: ${___skipAPIurl}`);
         if (conversationDetailCount > 10) {
             pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
@@ -999,7 +1423,7 @@ let AskSkipResolver = class AskSkipResolver {
                 apiRequest.requestPhase = 'data_gathering_response';
             }
             conversationDetailCount++;
-            return this.HandleSkipRequest(apiRequest, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount);
+            return this.HandleSkipChatRequest(apiRequest, UserQuestion, user, dataSource, ConversationId, userPayload, pubSub, md, convoEntity, convoDetailEntity, dataContext, dataContextEntity, conversationDetailCount);
         }
         catch (e) {
             LogError(e);
@@ -1066,6 +1490,16 @@ let AskSkipResolver = class AskSkipResolver {
             AIMessageConversationDetailID: convoDetailEntityAI.ID,
         };
     }
+    getAgentNoteTypeIDByName(name) {
+        const noteTypeID = AIEngine.Instance.AgentNoteTypes.find(nt => nt.Name.trim().toLowerCase() === name.trim().toLowerCase())?.ID;
+        if (noteTypeID) {
+            return noteTypeID;
+        }
+        else {
+            const AINoteTypeID = AIEngine.Instance.AgentNoteTypes.find(nt => nt.Name.trim().toLowerCase() === 'AI')?.ID;
+            return AINoteTypeID;
+        }
+    }
     async getViewData(ViewId, user) {
         const rv = new RunView();
         const result = await rv.RunView({ ViewID: ViewId, IgnoreMaxRows: true }, user);
@@ -1074,6 +1508,93 @@ let AskSkipResolver = class AskSkipResolver {
         else
             throw new Error(`Error running view ${ViewId}`);
     }
+    async ManuallyExecuteSkipLearningCycle(OrganizationId) {
+        try {
+            LogStatus('Manual execution of Skip learning cycle requested via API');
+            const orgId = OrganizationId || ___skipAPIOrgId;
+            const result = await LearningCycleScheduler.Instance.manuallyExecuteLearningCycle(orgId);
+            return {
+                Success: result,
+                Message: result
+                    ? `Learning cycle was successfully executed manually for organization ${orgId}`
+                    : `Learning cycle execution failed for organization ${orgId}. Check server logs for details.`
+            };
+        }
+        catch (e) {
+            LogError(`Error in ManuallyExecuteSkipLearningCycle: ${e}`);
+            return {
+                Success: false,
+                Message: `Error executing learning cycle: ${e}`
+            };
+        }
+    }
+    async GetLearningCycleStatus() {
+        try {
+            const status = LearningCycleScheduler.Instance.getStatus();
+            return {
+                IsSchedulerRunning: status.isSchedulerRunning,
+                LastRunTime: status.lastRunTime ? status.lastRunTime.toISOString() : null,
+                RunningOrganizations: status.runningOrganizations ? status.runningOrganizations.map(org => ({
+                    OrganizationId: org.organizationId,
+                    LearningCycleId: org.learningCycleId,
+                    StartTime: org.startTime.toISOString(),
+                    RunningForMinutes: org.runningForMinutes
+                })) : []
+            };
+        }
+        catch (e) {
+            LogError(`Error in GetLearningCycleStatus: ${e}`);
+            return {
+                IsSchedulerRunning: false,
+                LastRunTime: null,
+                RunningOrganizations: []
+            };
+        }
+    }
+    async IsOrganizationRunningLearningCycle(OrganizationId) {
+        try {
+            const orgId = OrganizationId || ___skipAPIOrgId;
+            const status = LearningCycleScheduler.Instance.isOrganizationRunningCycle(orgId);
+            if (!status.isRunning) {
+                return null;
+            }
+            return {
+                OrganizationId: orgId,
+                LearningCycleId: status.learningCycleId,
+                StartTime: status.startTime.toISOString(),
+                RunningForMinutes: status.runningForMinutes
+            };
+        }
+        catch (e) {
+            LogError(`Error in IsOrganizationRunningLearningCycle: ${e}`);
+            return null;
+        }
+    }
+    async StopLearningCycleForOrganization(OrganizationId) {
+        try {
+            const orgId = OrganizationId || ___skipAPIOrgId;
+            const result = LearningCycleScheduler.Instance.stopLearningCycleForOrganization(orgId);
+            return {
+                Success: result.success,
+                Message: result.message,
+                WasRunning: result.wasRunning,
+                CycleDetails: result.cycleDetails ? {
+                    LearningCycleId: result.cycleDetails.learningCycleId,
+                    StartTime: result.cycleDetails.startTime.toISOString(),
+                    RunningForMinutes: result.cycleDetails.runningForMinutes
+                } : null
+            };
+        }
+        catch (e) {
+            LogError(`Error in StopLearningCycleForOrganization: ${e}`);
+            return {
+                Success: false,
+                Message: `Error stopping learning cycle: ${e}`,
+                WasRunning: false,
+                CycleDetails: null
+            };
+        }
+    }
 };
 __decorate([
     Query(() => AskSkipResultType),
@@ -1087,6 +1608,14 @@ __decorate([
     __metadata("design:paramtypes", [String, String, String, CompositeKeyInputType, Object, PubSubEngine]),
     __metadata("design:returntype", Promise)
 ], AskSkipResolver.prototype, "ExecuteAskSkipRecordChat", null);
+__decorate([
+    Mutation(() => AskSkipResultType),
+    __param(0, Ctx()),
+    __param(1, Arg('ForceEntityRefresh', () => Boolean, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ExecuteAskSkipLearningCycle", null);
 __decorate([
     Query(() => AskSkipResultType),
     __param(0, Ctx()),
@@ -1109,6 +1638,33 @@ __decorate([
     __metadata("design:paramtypes", [String, String, Object, PubSubEngine, String, Boolean]),
     __metadata("design:returntype", Promise)
 ], AskSkipResolver.prototype, "ExecuteAskSkipAnalysisQuery", null);
+__decorate([
+    Mutation(() => ManualLearningCycleResultType),
+    __param(0, Arg('OrganizationId', () => String, { nullable: true })),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "ManuallyExecuteSkipLearningCycle", null);
+__decorate([
+    Query(() => LearningCycleStatusType),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "GetLearningCycleStatus", null);
+__decorate([
+    Query(() => RunningOrganizationType, { nullable: true }),
+    __param(0, Arg('OrganizationId', () => String)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "IsOrganizationRunningLearningCycle", null);
+__decorate([
+    Mutation(() => StopLearningCycleResultType),
+    __param(0, Arg('OrganizationId', () => String)),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], AskSkipResolver.prototype, "StopLearningCycleForOrganization", null);
 AskSkipResolver = AskSkipResolver_1 = __decorate([
     Resolver(AskSkipResultType)
 ], AskSkipResolver);