@memberjunction/server 2.43.0 → 2.45.0

package/src/generic/ResolverBase.ts

@@ -742,6 +742,7 @@ export class ResolverBase {
       if (await entityObject.Save()) {
         // save worked, fire afterevent and return all the data
         await this.AfterUpdate(dataSource, input); // fire event
+        
         return this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll());
       } else {
         throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {
@@ -753,7 +754,7 @@ export class ResolverBase {
         extensions: { code: 'SAVE_ENTITY_ERROR', entityName },
       });
   }
-
+  
   /**
    * This routine compares the OldValues property in the input object to the values in the DB that we just loaded. If there are differences, we need to check to see if the client
    * is trying to update any of those fields (e.g. overlap). If there is overlap, we throw an error. If there is no overlap, we can proceed with the update even if the DB Values

package/src/index.ts

@@ -52,6 +52,8 @@ export { TokenExpiredError, getSystemUser } from './auth/index.js';
 export * from './generic/PushStatusResolver.js';
 export * from './generic/ResolverBase.js';
 export * from './generic/RunViewResolver.js';
+export * from './resolvers/RunTemplateResolver.js';
+export * from './resolvers/RunAIPromptResolver.js';
 export * from './generic/KeyValuePairInput.js';
 export * from './generic/KeyInputOutputTypes.js';
 export * from './generic/DeleteOptionsInput.js';

package/src/resolvers/AskSkipResolver.ts

@@ -51,6 +51,7 @@ import {
   DataContextEntity,
   DataContextItemEntity,
   UserNotificationEntity,
+  AIAgentEntityExtended
 } from '@memberjunction/core-entities';
 import { DataSource } from 'typeorm';
 import { apiKey, baseUrl, configInfo, graphqlPort, mj_core_schema } from '../config.js';
@@ -60,7 +61,7 @@ import { MJGlobal, CopyScalarsAndArrays } from '@memberjunction/global';
 import { sendPostRequest } from '../util.js';
 import { GetAIAPIKey } from '@memberjunction/ai';
 import { CompositeKeyInputType } from '../generic/KeyInputOutputTypes.js';
-import { AIAgentEntityExtended, AIEngine } from '@memberjunction/aiengine';
+import { AIEngine } from '@memberjunction/aiengine';
 import { deleteAccessToken, GetDataAccessToken, registerAccessToken, tokenExists } from './GetDataResolver.js';
 import e from 'express';
 
@@ -414,7 +415,7 @@ export class AskSkipResolver {
       conversationDetailID: convoDetailEntity.ID,
     });
 
-    return this.handleSimpleSkipChatPostRequest(input, convoEntity.ID, convoDetailEntity.ID, true, user);
+    return this.handleSimpleSkipChatPostRequest(input, convoEntity, convoDetailEntity, true, user);
   }
 
   /**
@@ -641,51 +642,69 @@ export class AskSkipResolver {
    * Sends the chat request and processes the response
    * 
    * @param input The chat request payload
-   * @param conversationID ID of the conversation, or empty for a new conversation
-   * @param UserMessageConversationDetailId ID of the user's message in the conversation
+   * @param convoEntity The conversation entity object
+   * @param convoDetailEntity The conversation detail entity object
    * @param createAIMessageConversationDetail Whether to create a conversation detail for the AI response
    * @param user User context for the request
    * @returns Result of the Skip interaction
    */
   protected async handleSimpleSkipChatPostRequest(
     input: SkipAPIRequest,
-    conversationID: string = '',
-    UserMessageConversationDetailId: string = '',
+    convoEntity: ConversationEntity = null,
+    convoDetailEntity: ConversationDetailEntity = null,
     createAIMessageConversationDetail: boolean = false,
     user: UserInfo = null
   ): Promise<AskSkipResultType> {
     const skipConfigInfo = configInfo.askSkip;
     LogStatus(`   >>> HandleSimpleSkipChatPostRequest Sending request to Skip API: ${skipConfigInfo.chatURL}`);
 
-    const response = await sendPostRequest(skipConfigInfo.chatURL, input, true, null);
-
-    if (response && response.length > 0) {
-      // the last object in the response array is the final response from the Skip API
-      const apiResponse = <SkipAPIResponse>response[response.length - 1].value;
-      const AIMessageConversationDetailID = createAIMessageConversationDetail
-        ? await this.CreateAIMessageConversationDetail(apiResponse, conversationID, user)
-        : '';
-      //      const apiResponse = <SkipAPIResponse>response.data;
-      LogStatus(`  Skip API response: ${apiResponse.responsePhase}`);
-      return {
-        Success: true,
-        Status: 'OK',
-        ResponsePhase: SkipResponsePhase.AnalysisComplete,
-        ConversationId: conversationID,
-        UserMessageConversationDetailId: UserMessageConversationDetailId,
-        AIMessageConversationDetailId: AIMessageConversationDetailID,
-        Result: JSON.stringify(apiResponse),
-      };
-    } else {
-      return {
-        Success: false,
-        Status: 'Error',
-        Result: `Request failed`,
-        ResponsePhase: SkipResponsePhase.AnalysisComplete,
-        ConversationId: conversationID,
-        UserMessageConversationDetailId: UserMessageConversationDetailId,
-        AIMessageConversationDetailId: '',
-      };
+    try {
+      const response = await sendPostRequest(skipConfigInfo.chatURL, input, true, null);
+
+      if (response && response.length > 0) {
+        // the last object in the response array is the final response from the Skip API
+        const apiResponse = <SkipAPIResponse>response[response.length - 1].value;
+        const AIMessageConversationDetailID = createAIMessageConversationDetail && convoEntity
+          ? await this.CreateAIMessageConversationDetail(apiResponse, convoEntity.ID, user)
+          : '';
+        //      const apiResponse = <SkipAPIResponse>response.data;
+        LogStatus(`  Skip API response: ${apiResponse.responsePhase}`);
+        return {
+          Success: true,
+          Status: 'OK',
+          ResponsePhase: SkipResponsePhase.AnalysisComplete,
+          ConversationId: convoEntity ? convoEntity.ID : '',
+          UserMessageConversationDetailId: convoDetailEntity ? convoDetailEntity.ID : '',
+          AIMessageConversationDetailId: AIMessageConversationDetailID,
+          Result: JSON.stringify(apiResponse),
+        };
+      } else {
+        // Set conversation status to Available on failure so user can try again (if conversation exists)
+        if (convoEntity) {
+          await this.setConversationStatus(convoEntity, 'Available');
+        }
+        
+        return {
+          Success: false,
+          Status: 'Error',
+          Result: `Request failed`,
+          ResponsePhase: SkipResponsePhase.AnalysisComplete,
+          ConversationId: convoEntity ? convoEntity.ID : '',
+          UserMessageConversationDetailId: convoDetailEntity ? convoDetailEntity.ID : '',
+          AIMessageConversationDetailId: '',
+        };
+      }
+    } catch (error) {
+      // Set conversation status to Available on error so user can try again (if conversation exists)
+      if (convoEntity) {
+        await this.setConversationStatus(convoEntity, 'Available');
+      }
+      
+      // Log the error for debugging
+      LogError(`Error in handleSimpleSkipChatPostRequest: ${error}`);
+      
+      // Re-throw the error to propagate it up the stack
+      throw error;
     }
   }
 
@@ -1343,7 +1362,7 @@ cycle.`);
     );
 
     // Set the conversation status to 'Processing' when a request is initiated
-    this.setConversationStatus(convoEntity, 'Processing');
+    await this.setConversationStatus(convoEntity, 'Processing');
 
     // now load up the messages. We will load up ALL of the messages for this conversation, and then pass them to the Skip API
     const messages: SkipMessage[] = await this.LoadConversationDetailsIntoSkipMessages(
@@ -1641,7 +1660,8 @@ cycle.`);
   
       // get the list of entities
       const entities = md.Entities.filter((e) => {
-        if (e.SchemaName !== mj_core_schema || skipSpecialIncludeEntities.includes(e.Name.trim().toLowerCase())) {
+        if (!configInfo.askSkip.entitiesToSend.excludeSchemas.includes(e.SchemaName) ||
+            skipSpecialIncludeEntities.includes(e.Name.trim().toLowerCase())) {
           const sd = e.ScopeDefault?.trim();
           if (sd && sd.length > 0) {
             const scopes = sd.split(',').map((s) => s.trim().toLowerCase()) ?? ['all'];
@@ -1941,6 +1961,7 @@ cycle.`);
     const convoDetailEntity = await md.GetEntityObject<ConversationDetailEntity>('Conversation Details', user);
     convoDetailEntity.NewRecord();
     convoDetailEntity.ConversationID = ConversationId;
+    convoDetailEntity.UserID = user.ID;
     convoDetailEntity.Message = UserQuestion;
     convoDetailEntity.Role = 'User';
     convoDetailEntity.HiddenToUser = false;
@@ -2141,38 +2162,61 @@ cycle.`);
       };
     }
 
-    const response = await sendPostRequest(
-      skipConfigInfo.chatURL,
-      input,
-      true,
-      null,
-      (message: {
-        type: string;
-        value: {
-          success: boolean;
-          error: string;
-          responsePhase: string;
-          messages: {
-            role: string;
-            content: string;
-          }[];
-        };
-      }) => {
-        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,
-          });
+    let response;
+    try {
+      response = await sendPostRequest(
+        skipConfigInfo.chatURL,
+        input,
+        true,
+        null,
+        (message: {
+          type: string;
+          value: {
+            success: boolean;
+            error: string;
+            responsePhase: string;
+            messages: {
+              role: string;
+              content: string;
+            }[];
+          };
+        }) => {
+          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,
+            });
+          }
         }
-      }
-    );
+      );
+    } catch (error) {
+      // Set conversation status to Available on error so user can try again
+      await this.setConversationStatus(convoEntity, 'Available');
+      
+      // Log the error for debugging
+      LogError(`Error in HandleSkipChatRequest sendPostRequest: ${error}`);
+      
+      // Publish error status update to user
+      pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+        message: JSON.stringify({
+          type: 'AskSkip',
+          status: 'Error',
+          conversationID: ConversationId,
+          message: 'Request failed. Please try again later and if this continues, contact your support desk.',
+        }),
+        sessionId: userPayload.sessionId,
+      });
+      
+      // Re-throw the error to propagate it up the stack
+      throw error;
+    }
 
     if (response && response.length > 0) {
       // response.status === 200) {
@@ -2409,7 +2453,7 @@ cycle.`);
     convoDetailEntityAI.CompletionTime = endTime.getTime() - startTime.getTime();
     
     // Set conversation status back to Available since we need user input for the clarifying question
-    this.setConversationStatus(convoEntity, 'Available');
+    await this.setConversationStatus(convoEntity, 'Available');
     
     if (await convoDetailEntityAI.Save()) {
       return {
@@ -2637,7 +2681,7 @@ cycle.`);
     dataSource: DataSource,
     startTime: Date
   ): Promise<{ AIMessageConversationDetailID: string }> {
-    const sTitle = apiResponse.reportTitle;
+    const sTitle = apiResponse.title;
     const sResult = JSON.stringify(apiResponse);
 
     // first up, let's see if Skip asked us to create an artifact or add a new version to an existing artifact, or NOT
@@ -2804,12 +2848,12 @@ cycle.`);
 
   private async setConversationStatus(convoEntity: ConversationEntity, status: 'Processing' | 'Available'): Promise<boolean> {
     if (convoEntity.Status !== status) {
-      convoEntity.Status = status;
-      const convoSaveResult = await convoEntity.Save();
-      if (!convoSaveResult) {
-        LogError(`Error updating conversation status to '${status}'`, undefined, convoEntity.LatestResult);
-      }
-      return convoSaveResult;
+    convoEntity.Status = status;
+    const convoSaveResult = await convoEntity.Save();
+    if (!convoSaveResult) {
+      LogError(`Error updating conversation status to '${status}'`, undefined, convoEntity.LatestResult);
+    }
+    return convoSaveResult;
     }
     return true;
   }

package/src/resolvers/ReportResolver.ts

@@ -96,7 +96,10 @@ export class ReportResolverExtended {
 
       const report = await md.GetEntityObject<ReportEntity>('Reports', u);
       report.NewRecord();
-      report.Name = skipData.reportTitle ? skipData.reportTitle : 'Untitled Report';
+      // support the legacy report title as old conversation details had a reportTitle property
+      // but the new SkipData object has a title property, so favor the title property
+      const title = skipData.title ? skipData.title : skipData.reportTitle ? skipData.reportTitle : 'Untitled Report';
+      report.Name = title;
       report.Description = skipData.userExplanation ? skipData.userExplanation : '';
       report.ConversationID = result[0].ConversationID;
       report.ConversationDetailID = ConversationDetailID;

package/src/resolvers/RunAIPromptResolver.ts

@@ -0,0 +1,169 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+import { UserPayload } from '../types.js';
+import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { AIPromptEntity } from '@memberjunction/core-entities';
+import { AIPromptRunner, AIPromptParams } from '@memberjunction/ai-prompts';
+import { ResolverBase } from '../generic/ResolverBase.js';
+
+@ObjectType()
+export class AIPromptRunResult {
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    output?: string;
+
+    @Field({ nullable: true })
+    parsedResult?: string;
+
+    @Field({ nullable: true })
+    error?: string;
+
+    @Field({ nullable: true })
+    executionTimeMs?: number;
+
+    @Field({ nullable: true })
+    tokensUsed?: number;
+
+    @Field({ nullable: true })
+    promptRunId?: string;
+
+    @Field({ nullable: true })
+    rawResult?: string;
+
+    @Field({ nullable: true })
+    validationResult?: string;
+}
+
+@Resolver()
+export class RunAIPromptResolver extends ResolverBase {
+    @Mutation(() => AIPromptRunResult)
+    async RunAIPrompt(
+        @Arg('promptId') promptId: string,
+        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Arg('data', { nullable: true }) data?: string,
+        @Arg('modelId', { nullable: true }) modelId?: string,
+        @Arg('vendorId', { nullable: true }) vendorId?: string,
+        @Arg('configurationId', { nullable: true }) configurationId?: string,
+        @Arg('skipValidation', { nullable: true }) skipValidation?: boolean,
+        @Arg('templateData', { nullable: true }) templateData?: string
+    ): Promise<AIPromptRunResult> {
+        const startTime = Date.now();
+        
+        try {
+            LogStatus(`=== RUNNING AI PROMPT FOR ID: ${promptId} ===`);
+
+            // Parse data contexts (JSON strings)
+            let parsedData = {};
+            let parsedTemplateData = {};
+            
+            if (data) {
+                try {
+                    parsedData = JSON.parse(data);
+                } catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Invalid JSON in data: ${(parseError as Error).message}`,
+                        executionTimeMs: Date.now() - startTime
+                    };
+                }
+            }
+
+            if (templateData) {
+                try {
+                    parsedTemplateData = JSON.parse(templateData);
+                } catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Invalid JSON in template data: ${(parseError as Error).message}`,
+                        executionTimeMs: Date.now() - startTime
+                    };
+                }
+            }
+
+            // Get current user from payload
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return {
+                    success: false,
+                    error: 'Unable to determine current user',
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+            
+            const md = new Metadata();
+            
+            // Load the AI prompt entity
+            const promptEntity = await md.GetEntityObject<AIPromptEntity>('AI Prompts', currentUser);
+            await promptEntity.Load(promptId);
+            
+            if (!promptEntity.IsSaved) {
+                return {
+                    success: false,
+                    error: `AI Prompt with ID ${promptId} not found`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Check if prompt is active
+            if (promptEntity.Status !== 'Active') {
+                return {
+                    success: false,
+                    error: `AI Prompt "${promptEntity.Name}" is not active (Status: ${promptEntity.Status})`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Create AI prompt runner and execute
+            const promptRunner = new AIPromptRunner();
+            
+            // Build execution parameters
+            const promptParams = new AIPromptParams();
+            promptParams.prompt = promptEntity;
+            promptParams.data = parsedData;
+            promptParams.templateData = parsedTemplateData;
+            promptParams.modelId = modelId;
+            promptParams.vendorId = vendorId;
+            promptParams.configurationId = configurationId;
+            promptParams.contextUser = currentUser;
+            promptParams.skipValidation = skipValidation || false;
+
+            // Execute the prompt
+            const result = await promptRunner.ExecutePrompt(promptParams);
+
+            const executionTime = Date.now() - startTime;
+
+            if (result.success) {
+                LogStatus(`=== AI PROMPT RUN COMPLETED FOR: ${promptEntity.Name} (${executionTime}ms) ===`);
+                
+                return {
+                    success: true,
+                    output: result.rawResult,
+                    parsedResult: typeof result.result === 'string' ? result.result : JSON.stringify(result.result),
+                    rawResult: result.rawResult,
+                    executionTimeMs: executionTime,
+                    tokensUsed: result.tokensUsed,
+                    promptRunId: result.promptRun?.ID,
+                    validationResult: result.validationResult ? JSON.stringify(result.validationResult) : undefined
+                };
+            } else {
+                LogError(`AI Prompt run failed for ${promptEntity.Name}: ${result.errorMessage}`);
+                return {
+                    success: false,
+                    error: result.errorMessage,
+                    executionTimeMs: executionTime,
+                    promptRunId: result.promptRun?.ID
+                };
+            }
+
+        } catch (error) {
+            const executionTime = Date.now() - startTime;
+            LogError(`AI Prompt run failed:`, undefined, error);
+            return {
+                success: false,
+                error: (error as Error).message || 'Unknown error occurred',
+                executionTimeMs: executionTime
+            };
+        }
+    }
+}

package/src/resolvers/RunTemplateResolver.ts

@@ -0,0 +1,130 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field } from 'type-graphql';
+import { UserPayload } from '../types.js';
+import { LogError, LogStatus, Metadata, RunView } from '@memberjunction/core';
+import { TemplateContentEntity } from '@memberjunction/core-entities';
+import { TemplateEngineServer } from '@memberjunction/templates';
+import { TemplateEntityExtended } from '@memberjunction/templates-base-types';
+import { ResolverBase } from '../generic/ResolverBase.js';
+
+@ObjectType()
+export class TemplateRunResult {
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    output?: string;
+
+    @Field({ nullable: true })
+    error?: string;
+
+    @Field({ nullable: true })
+    executionTimeMs?: number;
+}
+
+@Resolver()
+export class RunTemplateResolver extends ResolverBase {
+    @Mutation(() => TemplateRunResult)
+    async RunTemplate(
+        @Arg('templateId') templateId: string,
+        @Ctx() { userPayload }: { userPayload: UserPayload },
+        @Arg('contextData', { nullable: true }) contextData?: string
+    ): Promise<TemplateRunResult> {
+        const startTime = Date.now();
+        
+        try {
+            LogStatus(`=== RUNNING TEMPLATE FOR ID: ${templateId} ===`);
+
+            // Parse context data (JSON string)
+            let data = {};
+            if (contextData) {
+                try {
+                    data = JSON.parse(contextData);
+                } catch (parseError) {
+                    return {
+                        success: false,
+                        error: `Invalid JSON in context data: ${(parseError as Error).message}`,
+                        executionTimeMs: Date.now() - startTime
+                    };
+                }
+            }
+
+            // Get current user from payload
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                return {
+                    success: false,
+                    error: 'Unable to determine current user',
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+            
+            const md = new Metadata();
+            
+            // Load the template entity
+            const templateEntity = await md.GetEntityObject<TemplateEntityExtended>('Templates', currentUser);
+            await templateEntity.Load(templateId);
+            
+            if (!templateEntity.IsSaved) {
+                return {
+                    success: false,
+                    error: `Template with ID ${templateId} not found`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Load template content (get the first/highest priority content)
+            const rv = new RunView();
+            const templateContentResult = await rv.RunView<TemplateContentEntity>({
+                EntityName: 'Template Contents',
+                ExtraFilter: `TemplateID = '${templateId}'`,
+                OrderBy: 'Priority ASC',
+                MaxRows: 1,
+                ResultType: 'entity_object'
+            }, currentUser);
+
+            if (!templateContentResult.Results || templateContentResult.Results.length === 0) {
+                return {
+                    success: false,
+                    error: `No template content found for template ${templateEntity.Name}`,
+                    executionTimeMs: Date.now() - startTime
+                };
+            }
+
+            // Configure and render the template
+            await TemplateEngineServer.Instance.Config(true /*always refresh to get latest templates*/, currentUser);
+            const result = await TemplateEngineServer.Instance.RenderTemplate(
+                templateEntity, 
+                templateContentResult.Results[0], 
+                data, 
+                true // skip validation for execution
+            );
+
+            const executionTime = Date.now() - startTime;
+
+            if (result.Success) {
+                LogStatus(`=== TEMPLATE RUN COMPLETED FOR: ${templateEntity.Name} (${executionTime}ms) ===`);
+                return {
+                    success: true,
+                    output: result.Output,
+                    executionTimeMs: executionTime
+                };
+            } else {
+                LogError(`Template run failed for ${templateEntity.Name}: ${result.Message}`);
+                return {
+                    success: false,
+                    error: result.Message,
+                    executionTimeMs: executionTime
+                };
+            }
+
+        } catch (error) {
+            const executionTime = Date.now() - startTime;
+            LogError(`Template run failed:`, undefined, error);
+            return {
+                success: false,
+                error: (error as Error).message || 'Unknown error occurred',
+                executionTimeMs: executionTime
+            };
+        }
+    }
+}