@memberjunction/server 2.129.0 → 2.130.0

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,15 +1,17 @@
-import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID } from 'type-graphql';
+import { Resolver, Mutation, Query, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine, Subscription, Root, ResolverFilterData, ID, Int } from 'type-graphql';
 import { AppContext, UserPayload } from '../types.js';
-import { DatabaseProviderBase, LogError, LogStatus, Metadata, UserInfo } from '@memberjunction/core';
-import { ConversationDetailEntity, UserNotificationEntity } from '@memberjunction/core-entities';
+import { DatabaseProviderBase, LogError, LogStatus, Metadata, RunView, UserInfo } from '@memberjunction/core';
+import { ConversationDetailEntity, ConversationDetailAttachmentEntity, UserNotificationEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
-import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult } from '@memberjunction/ai-core-plus';
+import { AIAgentEntityExtended, AIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
+import { ChatMessage } from '@memberjunction/ai';
 import { ResolverBase } from '../generic/ResolverBase.js';
 import { PUSH_STATUS_UPDATES_TOPIC } from '../generic/PushStatusResolver.js';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { GetReadWriteProvider } from '../util.js';
 import { SafeJSONParse } from '@memberjunction/global';
+import { getAttachmentService } from '@memberjunction/aiengine';
 
 @ObjectType()
 export class AIAgentRunResult {
@@ -699,4 +701,190 @@ export class RunAIAgentResolver extends ResolverBase {
         }
     }
 
+    /**
+     * Optimized mutation that loads conversation history server-side.
+     * This avoids sending large attachment data from client to server.
+     *
+     * @param conversationDetailId - The conversation detail ID (user's message already saved)
+     * @param agentId - The agent to execute
+     * @param maxHistoryMessages - Maximum number of history messages to include (default: 20)
+     */
+    @Mutation(() => AIAgentRunResult)
+    async RunAIAgentFromConversationDetail(
+        @Arg('conversationDetailId') conversationDetailId: string,
+        @Arg('agentId') agentId: string,
+        @Ctx() { userPayload, providers, dataSource }: AppContext,
+        @Arg('sessionId') sessionId: string,
+        @PubSub() pubSub: PubSubEngine,
+        @Arg('maxHistoryMessages', () => Int, { nullable: true }) maxHistoryMessages?: number,
+        @Arg('data', { nullable: true }) data?: string,
+        @Arg('payload', { nullable: true }) payload?: string,
+        @Arg('lastRunId', { nullable: true }) lastRunId?: string,
+        @Arg('autoPopulateLastRunPayload', { nullable: true }) autoPopulateLastRunPayload?: boolean,
+        @Arg('configurationId', { nullable: true }) configurationId?: string,
+        @Arg('createArtifacts', { nullable: true }) createArtifacts?: boolean,
+        @Arg('createNotification', { nullable: true }) createNotification?: boolean,
+        @Arg('sourceArtifactId', { nullable: true }) sourceArtifactId?: string,
+        @Arg('sourceArtifactVersionId', { nullable: true }) sourceArtifactVersionId?: string
+    ): Promise<AIAgentRunResult> {
+        const p = GetReadWriteProvider(providers);
+        const currentUser = this.GetUserFromPayload(userPayload);
+
+        if (!currentUser) {
+            return {
+                success: false,
+                errorMessage: 'Unable to determine current user',
+                result: JSON.stringify({ success: false, errorMessage: 'Unable to determine current user' })
+            };
+        }
+
+        try {
+            // Load conversation history with attachments from DB
+            const messages = await this.loadConversationHistoryWithAttachments(
+                conversationDetailId,
+                currentUser,
+                maxHistoryMessages || 20
+            );
+
+            // Convert to JSON string for the existing executeAIAgent method
+            const messagesJson = JSON.stringify(messages);
+
+            // Delegate to existing implementation
+            return this.executeAIAgent(
+                p,
+                dataSource,
+                agentId,
+                userPayload,
+                messagesJson,
+                sessionId,
+                pubSub,
+                data,
+                payload,
+                undefined, // templateData
+                lastRunId,
+                autoPopulateLastRunPayload,
+                configurationId,
+                conversationDetailId,
+                createArtifacts || false,
+                createNotification || false,
+                sourceArtifactId,
+                sourceArtifactVersionId
+            );
+        } catch (error) {
+            const errorMessage = (error as Error).message || 'Unknown error loading conversation history';
+            LogError(`RunAIAgentFromConversationDetail failed: ${errorMessage}`, undefined, error);
+            return {
+                success: false,
+                errorMessage,
+                result: JSON.stringify({ success: false, errorMessage })
+            };
+        }
+    }
+
+    /**
+     * Load conversation history with attachments from database.
+     * Builds ChatMessage[] with multimodal content blocks for attachments.
+     */
+    private async loadConversationHistoryWithAttachments(
+        conversationDetailId: string,
+        contextUser: UserInfo,
+        maxMessages: number
+    ): Promise<ChatMessage[]> {
+        const md = new Metadata();
+        const rv = new RunView();
+        const attachmentService = getAttachmentService();
+
+        // Load the current conversation detail to get the conversation ID
+        const currentDetail = await md.GetEntityObject<ConversationDetailEntity>(
+            'Conversation Details',
+            contextUser
+        );
+        if (!await currentDetail.Load(conversationDetailId)) {
+            throw new Error(`Conversation detail ${conversationDetailId} not found`);
+        }
+
+        const conversationId = currentDetail.ConversationID;
+
+        // Load recent conversation details (messages) for this conversation
+        const detailsResult = await rv.RunView<ConversationDetailEntity>({
+            EntityName: 'Conversation Details',
+            ExtraFilter: `ConversationID='${conversationId}'`,
+            OrderBy: '__mj_CreatedAt DESC',
+            MaxRows: maxMessages,
+            ResultType: 'entity_object'
+        }, contextUser);
+
+        if (!detailsResult.Success || !detailsResult.Results) {
+            throw new Error('Failed to load conversation history');
+        }
+
+        // Reverse to get chronological order (oldest first)
+        const details = detailsResult.Results.reverse();
+
+        // Get all message IDs for batch loading attachments
+        const messageIds = details.map(d => d.ID);
+
+        // Batch load all attachments for these messages
+        const attachmentsByDetailId = await attachmentService.getAttachmentsBatch(messageIds, contextUser);
+
+        // Build ChatMessage array with attachments
+        const messages: ChatMessage[] = [];
+
+        for (const detail of details) {
+            const role = this.mapDetailRoleToMessageRole(detail.Role);
+            const attachments = attachmentsByDetailId.get(detail.ID) || [];
+
+            // Get attachment data with content URLs (handles both inline and FileID storage)
+            const attachmentDataPromises = attachments.map(att =>
+                attachmentService.getAttachmentData(att, contextUser)
+            );
+            const attachmentDataResults = await Promise.all(attachmentDataPromises);
+
+            // Filter out nulls and convert to AttachmentData format
+            const validAttachments: AttachmentData[] = attachmentDataResults
+                .filter((result): result is NonNullable<typeof result> => result !== null)
+                .map(result => ({
+                    type: ConversationUtility.GetAttachmentTypeFromMime(result.attachment.MimeType),
+                    mimeType: result.attachment.MimeType,
+                    fileName: result.attachment.FileName ?? undefined,
+                    sizeBytes: result.attachment.FileSizeBytes ?? undefined,
+                    width: result.attachment.Width ?? undefined,
+                    height: result.attachment.Height ?? undefined,
+                    durationSeconds: result.attachment.DurationSeconds ?? undefined,
+                    content: result.contentUrl
+                }));
+
+            // Build message content (with or without attachments)
+            let content: string | ReturnType<typeof ConversationUtility.BuildChatMessageContent>;
+
+            if (validAttachments.length > 0) {
+                // Use ConversationUtility to build multimodal content blocks
+                content = ConversationUtility.BuildChatMessageContent(
+                    detail.Message || '',
+                    validAttachments
+                );
+            } else {
+                content = detail.Message || '';
+            }
+
+            messages.push({
+                role,
+                content
+            });
+        }
+
+        return messages;
+    }
+
+    /**
+     * Map ConversationDetail Role to ChatMessage role
+     */
+    private mapDetailRoleToMessageRole(role: string): 'user' | 'assistant' | 'system' {
+        const roleLower = (role || '').toLowerCase();
+        if (roleLower === 'user') return 'user';
+        if (roleLower === 'assistant' || roleLower === 'agent') return 'assistant';
+        if (roleLower === 'system') return 'system';
+        return 'user'; // Default to user
+    }
+
 }

package/src/resolvers/RunTestResolver.ts

@@ -104,6 +104,7 @@ export class RunTestResolver extends ResolverBase {
         @Arg('testId') testId: string,
         @Arg('verbose', { nullable: true }) verbose: boolean = true,
         @Arg('environment', { nullable: true }) environment?: string,
+        @Arg('tags', { nullable: true }) tags?: string,
         @PubSub() pubSub?: PubSubEngine,
         @Ctx() { userPayload }: AppContext = {} as AppContext
     ): Promise<TestRunResult> {
@@ -132,6 +133,7 @@ export class RunTestResolver extends ResolverBase {
             const options = {
                 verbose,
                 environment,
+                tags,
                 progressCallback
             };
 
@@ -210,6 +212,10 @@ export class RunTestResolver extends ResolverBase {
         @Arg('verbose', { nullable: true }) verbose: boolean = true,
         @Arg('environment', { nullable: true }) environment?: string,
         @Arg('parallel', { nullable: true }) parallel: boolean = false,
+        @Arg('tags', { nullable: true }) tags?: string,
+        @Arg('selectedTestIds', { nullable: true }) selectedTestIds?: string,
+        @Arg('sequenceStart', () => Int, { nullable: true }) sequenceStart?: number,
+        @Arg('sequenceEnd', () => Int, { nullable: true }) sequenceEnd?: number,
         @PubSub() pubSub?: PubSubEngine,
         @Ctx() { userPayload }: AppContext = {} as AppContext
     ): Promise<TestSuiteRunResult> {
@@ -231,10 +237,24 @@ export class RunTestResolver extends ResolverBase {
                 this.createProgressCallback(pubSub, userPayload, suiteId) :
                 undefined;
 
+            // Parse selectedTestIds from JSON string if provided
+            let parsedSelectedTestIds: string[] | undefined;
+            if (selectedTestIds) {
+                try {
+                    parsedSelectedTestIds = JSON.parse(selectedTestIds);
+                } catch (e) {
+                    LogError(`[RunTestResolver] Failed to parse selectedTestIds: ${selectedTestIds}`);
+                }
+            }
+
             const options = {
                 verbose,
                 environment,
                 parallel,
+                tags,
+                selectedTestIds: parsedSelectedTestIds,
+                sequenceStart,
+                sequenceEnd,
                 progressCallback
             };