@memberjunction/server 5.10.1 → 5.12.0

package/src/generic/ResolverBase.ts

@@ -1061,7 +1061,7 @@ export class ResolverBase {
       if (await entityObject.Save()) {
         // save worked, fire the AfterCreate event and then return all the data
         await this.AfterCreate(provider, input); // fire event
-        this.PublishCacheInvalidation(entityObject, 'save', userPayload);
+        // Cache invalidation is now handled globally by the MJGlobal listener in index.ts
         const contextUser = this.GetUserFromPayload(userPayload);
         // MapFieldNamesToCodeNames now handles encryption filtering as well
         return await this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll(), contextUser);
@@ -1145,7 +1145,7 @@ export class ResolverBase {
       if (await entityObject.Save()) {
         // save worked, fire afterevent and return all the data
         await this.AfterUpdate(provider, input); // fire event
-        this.PublishCacheInvalidation(entityObject, 'save', userPayload);
+        // Cache invalidation is now handled globally by the MJGlobal listener in index.ts
 
         // MapFieldNamesToCodeNames now handles encryption filtering as well
         return await this.MapFieldNamesToCodeNames(entityName, entityObject.GetAll(), userInfo);
@@ -1372,7 +1372,7 @@ export class ResolverBase {
       
       if (await entityObject.Delete(options)) {
         await this.AfterDelete(provider, key); // fire event
-        this.PublishCacheInvalidation(entityObject, 'delete', userPayload);
+        // Cache invalidation is now handled globally by the MJGlobal listener in index.ts
         return returnValue;
       } else {
         throw new GraphQLError(entityObject.LatestResult?.Message ?? 'Unknown error', {

package/src/index.ts

@@ -4,8 +4,8 @@ dotenv.config({ quiet: true });
 
 import { expressMiddleware } from '@as-integrations/express5';
 import { mergeSchemas } from '@graphql-tools/schema';
-import { Metadata, DatabasePlatform, SetProvider, StartupManager as StartupManagerImport } from '@memberjunction/core';
-import { MJGlobal, UUIDsEqual } from '@memberjunction/global';
+import { Metadata, DatabasePlatform, SetProvider, StartupManager as StartupManagerImport, BaseEntity, BaseEntityEvent } from '@memberjunction/core';
+import { MJGlobal, MJEventType, UUIDsEqual } from '@memberjunction/global';
 import { setupSQLServerClient, SQLServerDataProvider, SQLServerProviderConfigData, UserCache } from '@memberjunction/sqlserver-dataprovider';
 import { extendConnectionPoolWithQuery } from './util.js';
 import { default as BodyParser } from 'body-parser';
@@ -426,6 +426,28 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
   }
   PubSubManager.Instance.SetPubSubEngine(pubSub as unknown as PubSubEngine);
 
+  // Global listener: broadcast CACHE_INVALIDATION to all browser clients whenever
+  // ANY BaseEntity save/delete occurs on this server — regardless of whether it
+  // originated from a GraphQL mutation or internal server-side code (agents, actions,
+  // task orchestrator, etc.).  This closes the gap where server-internal saves were
+  // invisible to browser BaseEngine caches.
+  MJGlobal.Instance.GetEventListener(false).subscribe((event) => {
+    if (event.event === MJEventType.ComponentEvent && event.eventCode === BaseEntity.BaseEventCode) {
+      const beEvent = event.args as BaseEntityEvent;
+      if (beEvent.type === 'save' || beEvent.type === 'delete') {
+        PubSubManager.Instance.Publish(CACHE_INVALIDATION_TOPIC, {
+          entityName: beEvent.baseEntity.EntityInfo.Name,
+          primaryKeyValues: JSON.stringify(beEvent.baseEntity.PrimaryKey.KeyValuePairs),
+          action: beEvent.type,
+          sourceServerId: MJGlobal.Instance.ProcessUUID,
+          timestamp: new Date(),
+          originSessionId: null,
+          recordData: beEvent.type === 'save' ? JSON.stringify(beEvent.baseEntity.GetAll()) : undefined,
+        });
+      }
+    }
+  });
+
   let schema = mergeSchemas({
     schemas: [
       buildSchemaSync({
@@ -505,6 +527,13 @@ export const serve = async (resolverPaths: Array<string>, app: Application = cre
     level: 6
   }));
 
+  // Health check endpoint - registered before auth middleware so cloud
+  // platform probes (Azure App Service, AWS ALB, k8s, etc.) don't
+  // generate noisy auth errors in the logs.
+  app.get('/healthcheck', (_req, res) => {
+    res.status(200).json({ status: 'ok' });
+  });
+
   // Apply user-provided Express middleware (after compression, before routes)
   if (options?.ExpressMiddlewareBefore) {
     for (const mw of options.ExpressMiddlewareBefore) {

package/src/resolvers/AdhocQueryResolver.ts

@@ -76,6 +76,8 @@ export class AdhocQueryResolver extends ResolverBase {
                 Results: JSON.stringify(result.recordset ?? []),
                 RowCount: result.recordset?.length ?? 0,
                 TotalRowCount: result.recordset?.length ?? 0,
+                PageNumber: undefined,
+                PageSize: undefined,
                 ExecutionTime: executionTimeMs,
                 ErrorMessage: ''
             };
@@ -92,6 +94,8 @@ export class AdhocQueryResolver extends ResolverBase {
                     Results: '[]',
                     RowCount: 0,
                     TotalRowCount: 0,
+                    PageNumber: undefined,
+                    PageSize: undefined,
                     ExecutionTime: executionTimeMs,
                     ErrorMessage: `Query execution exceeded ${input.TimeoutSeconds ?? 30} second timeout`
                 };
@@ -105,6 +109,8 @@ export class AdhocQueryResolver extends ResolverBase {
                 Results: '[]',
                 RowCount: 0,
                 TotalRowCount: 0,
+                PageNumber: undefined,
+                PageSize: undefined,
                 ExecutionTime: executionTimeMs,
                 ErrorMessage: `Query execution failed: ${errorMessage}`
             };
@@ -119,6 +125,8 @@ export class AdhocQueryResolver extends ResolverBase {
             Results: '[]',
             RowCount: 0,
             TotalRowCount: 0,
+            PageNumber: undefined,
+            PageSize: undefined,
             ExecutionTime: 0,
             ErrorMessage: errorMessage
         };

package/src/resolvers/CreateQueryResolver.ts

@@ -293,6 +293,9 @@ export class CreateQueryResultType {
     @Field(() => String, { nullable: true })
     EmbeddingModelName?: string;
 
+    @Field(() => String, { nullable: true })
+    TechnicalDescription?: string;
+
     // Related collections
     @Field(() => [QueryFieldType], { nullable: true })
     Fields?: QueryFieldType[];
@@ -349,6 +352,9 @@ export class UpdateQueryResultType {
     @Field(() => String, { nullable: true })
     EmbeddingModelName?: string;
 
+    @Field(() => String, { nullable: true })
+    TechnicalDescription?: string;
+
     // Related collections
     @Field(() => [QueryFieldType], { nullable: true })
     Fields?: QueryFieldType[];
@@ -477,6 +483,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
                     EmbeddingVector: record.EmbeddingVector,
                     EmbeddingModelID: record.EmbeddingModelID,
                     EmbeddingModelName: record.EmbeddingModel,
+                    TechnicalDescription: record.TechnicalDescription,
                     Fields: record.QueryFields.map(f => ({
                         ID: f.ID,
                         QueryID: f.QueryID,
@@ -540,6 +547,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
                         EmbeddingVector: existingQuery.EmbeddingVector,
                         EmbeddingModelID: existingQuery.EmbeddingModelID,
                         EmbeddingModelName: existingQuery.EmbeddingModel,
+                        TechnicalDescription: existingQuery.TechnicalDescription,
                         Fields: existingQuery.Fields?.map((f: any) => ({
                             ID: f.ID,
                             QueryID: f.QueryID,
@@ -736,6 +744,7 @@ export class MJQueryResolverExtended extends MJQueryResolver {
                 EmbeddingVector: queryEntity.EmbeddingVector,
                 EmbeddingModelID: queryEntity.EmbeddingModelID,
                 EmbeddingModelName: queryEntity.EmbeddingModel,
+                TechnicalDescription: queryEntity.TechnicalDescription,
                 Fields: queryEntity.QueryFields.map(f => ({
                     ID: f.ID,
                     QueryID: f.QueryID,

package/src/resolvers/GetDataResolver.ts

@@ -1,9 +1,11 @@
 import { Arg, Ctx, Field, InputType, ObjectType, Query } from 'type-graphql';
 import { AppContext } from '../types.js';
-import { LogError, LogStatus, Metadata } from '@memberjunction/core';
+import { LogError, LogStatus, Metadata, QueryCompositionEngine } from '@memberjunction/core';
 import { RequireSystemUser } from '../directives/RequireSystemUser.js';
 import { v4 as uuidv4 } from 'uuid';
 import { GetReadOnlyDataSource, GetReadOnlyProvider } from '../util.js';
+import { getDbType } from '../index.js';
+import { getSystemUser } from '../auth/index.js';
 import sql from 'mssql';
  
 @InputType() 
@@ -128,13 +130,27 @@ export class GetDataResolver {
                 throw new Error('Read-only data source not found');
             }
 
+            // Resolve composition tokens in queries before execution.
+            // Queries may contain {{query:"CategoryPath/QueryName(params)"}} tokens that
+            // reference reusable queries. These must be resolved to CTEs before raw SQL execution.
+            const compositionEngine = new QueryCompositionEngine();
+            const platform = getDbType();
+            const systemUser = await getSystemUser();
+
             // Execute all queries in parallel, but execute each individual query in its own try catch block so that if one fails, the others can still be processed
             // and also so that we can capture the error message for each query and return it
             const results = await Promise.allSettled(
                 input.Queries.map(async (query) => {
                     try {
+                        // Resolve composition tokens if present
+                        let resolvedSQL = query;
+                        if (compositionEngine.HasCompositionTokens(query)) {
+                            const compositionResult = compositionEngine.ResolveComposition(query, platform, systemUser);
+                            resolvedSQL = compositionResult.ResolvedSQL;
+                        }
+
                         const request = new sql.Request(readOnlyDataSource);
-                        const result = await request.query(query);
+                        const result = await request.query(resolvedSQL);
                         return { result: result.recordset, error: null };
                     } catch (err) {
                         // Extract clean SQL error message

package/src/resolvers/QueryResolver.ts

@@ -61,6 +61,12 @@ export class RunQueryResultType {
   @Field()
   TotalRowCount: number;
 
+  @Field(() => Int, { nullable: true })
+  PageNumber?: number;
+
+  @Field(() => Int, { nullable: true })
+  PageSize?: number;
+
   @Field()
   ExecutionTime: number;
 
@@ -233,6 +239,8 @@ export class RunQueryResolver extends ResolverBase {
       ExecutionTime: result.ExecutionTime ?? 0,
       ErrorMessage: result.ErrorMessage || '',
       AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+      PageNumber: result.PageNumber,
+      PageSize: result.PageSize,
       CacheHit: (result as any).CacheHit,
       CacheTTLRemaining: (result as any).CacheTTLRemaining
     };
@@ -276,6 +284,8 @@ export class RunQueryResolver extends ResolverBase {
       ExecutionTime: result.ExecutionTime ?? 0,
       ErrorMessage: result.ErrorMessage || '',
       AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+      PageNumber: result.PageNumber,
+      PageSize: result.PageSize,
       CacheHit: (result as any).CacheHit,
       CacheTTLRemaining: (result as any).CacheTTLRemaining
     };
@@ -332,6 +342,8 @@ export class RunQueryResolver extends ResolverBase {
       ExecutionTime: result.ExecutionTime ?? 0,
       ErrorMessage: result.ErrorMessage || '',
       AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+      PageNumber: result.PageNumber,
+      PageSize: result.PageSize,
       CacheHit: (result as any).CacheHit,
       CacheTTLRemaining: (result as any).CacheTTLRemaining
     };
@@ -374,6 +386,8 @@ export class RunQueryResolver extends ResolverBase {
       ExecutionTime: result.ExecutionTime ?? 0,
       ErrorMessage: result.ErrorMessage || '',
       AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+      PageNumber: result.PageNumber,
+      PageSize: result.PageSize,
       CacheHit: (result as any).CacheHit,
       CacheTTLRemaining: (result as any).CacheTTLRemaining
     };
@@ -424,6 +438,8 @@ export class RunQueryResolver extends ResolverBase {
         ExecutionTime: result.ExecutionTime ?? 0,
         ErrorMessage: result.ErrorMessage || '',
         AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+        PageNumber: result.PageNumber,
+        PageSize: result.PageSize,
         CacheHit: (result as Record<string, unknown>).CacheHit as boolean | undefined,
         CacheTTLRemaining: (result as Record<string, unknown>).CacheTTLRemaining as number | undefined
       };
@@ -471,6 +487,8 @@ export class RunQueryResolver extends ResolverBase {
         ExecutionTime: result.ExecutionTime ?? 0,
         ErrorMessage: result.ErrorMessage || '',
         AppliedParameters: result.AppliedParameters ? JSON.stringify(result.AppliedParameters) : undefined,
+        PageNumber: result.PageNumber,
+        PageSize: result.PageSize,
         CacheHit: (result as Record<string, unknown>).CacheHit as boolean | undefined,
         CacheTTLRemaining: (result as Record<string, unknown>).CacheTTLRemaining as number | undefined
       };

package/src/resolvers/RunAIAgentResolver.ts

@@ -1,7 +1,7 @@
 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, RunView, UserInfo } from '@memberjunction/core';
-import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity } from '@memberjunction/core-entities';
+import { MJConversationDetailEntity, MJConversationDetailAttachmentEntity, MJAIAgentRequestEntity } from '@memberjunction/core-entities';
 import { AgentRunner } from '@memberjunction/ai-agents';
 import { MJAIAgentEntityExtended, MJAIAgentRunEntityExtended, ExecuteAgentResult, ConversationUtility, AttachmentData } from '@memberjunction/ai-core-plus';
 import { AIEngine } from '@memberjunction/aiengine';
@@ -154,7 +154,8 @@ export class RunAIAgentResolver extends ResolverBase {
             errorMessage: result.agentRun?.ErrorMessage,
             finalStep: result.agentRun?.FinalStep,
             cancelled: result.agentRun?.Status === 'Cancelled',
-            cancellationReason: result.agentRun?.CancellationReason
+            cancellationReason: result.agentRun?.CancellationReason,
+            feedbackRequestId: result.feedbackRequestId
         };
 
         // Safely extract agent run data using GetAll() for proper serialization
@@ -433,6 +434,21 @@ export class RunAIAgentResolver extends ResolverBase {
 
             const executionTime = Date.now() - startTime;
 
+            // Sync feedback request if this is a continuation run (user responded via conversation)
+            if (lastRunId && result.agentRun?.ID) {
+                await this.syncFeedbackRequestFromConversation(
+                    lastRunId,
+                    result.agentRun.ID,
+                    userMessage,
+                    currentUser
+                );
+            }
+
+            // Send notification if agent created a feedback request (Chat step)
+            if (result.feedbackRequestId) {
+                await this.sendFeedbackRequestNotification(result, currentUser, pubSub, userPayload);
+            }
+
             // Create notification if enabled and artifact was created successfully
             if (createNotification && result.success && artifactInfo && artifactInfo.artifactId && artifactInfo.versionId && artifactInfo.versionNumber) {
                 await this.createCompletionNotification(
@@ -752,6 +768,112 @@ export class RunAIAgentResolver extends ResolverBase {
         }
     }
 
+    /**
+     * When a continuation run completes (lastRunId was provided), sync the corresponding
+     * AIAgentRequest by marking it as responded. This keeps the dashboard accurate when
+     * users respond to Chat steps via the conversation UI.
+     *
+     * Called server-side in the resolver so the conversation UI doesn't need any changes.
+     */
+    private async syncFeedbackRequestFromConversation(
+        lastRunId: string,
+        newRunId: string,
+        userMessage: string | undefined,
+        contextUser: UserInfo
+    ): Promise<void> {
+        try {
+            const rv = new RunView();
+            const result = await rv.RunView<MJAIAgentRequestEntity>({
+                EntityName: 'MJ: AI Agent Requests',
+                ExtraFilter: `OriginatingAgentRunID='${lastRunId}' AND Status='Requested'`,
+                MaxRows: 1,
+                ResultType: 'entity_object'
+            }, contextUser);
+
+            if (!result.Success || !result.Results || result.Results.length === 0) {
+                return; // No pending request for this run — normal for non-Chat continuations
+            }
+
+            const request = result.Results[0];
+            request.Status = 'Responded';
+            request.RespondedAt = new Date();
+            request.ResponseByUserID = contextUser.ID;
+            request.ResumingAgentRunID = newRunId;
+            if (userMessage) {
+                request.Response = userMessage;
+            }
+
+            const saved = await request.Save();
+            if (saved) {
+                LogStatus(`📋 Synced feedback request ${request.ID} → Responded (via conversation)`);
+            } else {
+                LogError(`Failed to save feedback request sync for ${request.ID}`);
+            }
+        } catch (error) {
+            // Don't let sync failure break the agent execution
+            LogError(`Error syncing feedback request: ${(error as Error).message}`);
+        }
+    }
+
+    /**
+     * Sends a notification when an agent creates a feedback request (Chat step).
+     * Called after execution completes if the result contains a feedbackRequestId.
+     */
+    private async sendFeedbackRequestNotification(
+        result: ExecuteAgentResult,
+        contextUser: UserInfo,
+        pubSub: PubSubEngine,
+        userPayload: UserPayload
+    ): Promise<void> {
+        if (!result.feedbackRequestId) {
+            return;
+        }
+
+        try {
+            // Get agent name
+            await AIEngine.Instance.Config(false, contextUser);
+            const agent = AIEngine.Instance.Agents.find(a => UUIDsEqual(a.ID, result.agentRun?.AgentID));
+            const agentName = agent?.Name || 'Agent';
+
+            // Truncate message for notification
+            const message = result.agentRun?.Message || 'Agent needs your input';
+            const truncatedMessage = message.length > 200 ? message.substring(0, 197) + '...' : message;
+
+            const notificationEngine = NotificationEngine.Instance;
+            await notificationEngine.Config(false, contextUser);
+            const notifResult = await notificationEngine.SendNotification({
+                userId: contextUser.ID,
+                typeNameOrId: 'Agent Feedback Request',
+                title: `${agentName} needs your input`,
+                message: truncatedMessage,
+                resourceConfiguration: {
+                    type: 'agent-request',
+                    requestId: result.feedbackRequestId
+                }
+            }, contextUser);
+
+            if (notifResult.success && notifResult.inAppNotificationId) {
+                LogStatus(`📬 Feedback request notification sent (ID: ${notifResult.inAppNotificationId})`);
+
+                // Publish real-time notification event
+                pubSub.publish(PUSH_STATUS_UPDATES_TOPIC, {
+                    userPayload: JSON.stringify(userPayload),
+                    message: JSON.stringify({
+                        type: 'notification',
+                        notificationId: notifResult.inAppNotificationId,
+                        action: 'create',
+                        title: `${agentName} needs your input`,
+                        message: truncatedMessage
+                    })
+                });
+            } else if (!notifResult.success) {
+                LogError(`Feedback request notification failed: ${notifResult.errors?.join(', ')}`);
+            }
+        } catch (error) {
+            LogError(`Error sending feedback request notification: ${(error as Error).message}`);
+        }
+    }
+
     /**
      * Optimized mutation that loads conversation history server-side.
      * This avoids sending large attachment data from client to server.
@@ -854,6 +976,183 @@ export class RunAIAgentResolver extends ResolverBase {
         }
     }
 
+    /**
+     * Respond to a pending AIAgentRequest from the dashboard or API.
+     * Updates the request record with the response and optionally spawns a
+     * new agent run to resume execution with the human's input.
+     */
+    @Mutation(() => AIAgentRunResult)
+    async RespondToAgentRequest(
+        @Arg('requestId') requestId: string,
+        @Arg('status') status: string,
+        @Ctx() { userPayload, providers, dataSource }: AppContext,
+        @Arg('response', { nullable: true }) response?: string,
+        @Arg('responseData', { nullable: true }) responseData?: string,
+        @Arg('resumeAgent', { nullable: true }) resumeAgent?: boolean
+    ): Promise<AIAgentRunResult> {
+        const startTime = Date.now();
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                throw new Error('Unable to determine current user');
+            }
+
+            const md = new Metadata();
+            const request = await md.GetEntityObject<MJAIAgentRequestEntity>(
+                'MJ: AI Agent Requests',
+                currentUser
+            );
+            if (!(await request.Load(requestId))) {
+                throw new Error(`Agent request ${requestId} not found`);
+            }
+
+            if (request.Status !== 'Requested') {
+                throw new Error(`Request ${requestId} is already ${request.Status}, cannot respond`);
+            }
+
+            // Validate status
+            const validStatuses = ['Approved', 'Rejected', 'Responded'];
+            if (!validStatuses.includes(status)) {
+                throw new Error(`Invalid status "${status}". Must be one of: ${validStatuses.join(', ')}`);
+            }
+
+            // Update the request
+            request.Status = status as 'Approved' | 'Rejected' | 'Responded';
+            request.Response = response || null;
+            request.ResponseData = responseData || null;
+            request.RespondedAt = new Date();
+            request.ResponseByUserID = currentUser.ID;
+
+            const saved = await request.Save();
+            if (!saved) {
+                throw new Error(`Failed to save response for request ${requestId}`);
+            }
+
+            LogStatus(`📋 Agent request ${requestId} → ${status} by ${currentUser.Email || currentUser.ID}`);
+
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                executionTimeMs: executionTime,
+                result: JSON.stringify({
+                    success: true,
+                    requestId: requestId,
+                    status: status,
+                    resumed: false
+                })
+            };
+        } catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = (error as Error).message || 'Unknown error';
+            LogError(`RespondToAgentRequest failed: ${errorMessage}`, undefined, error);
+            return {
+                success: false,
+                errorMessage,
+                executionTimeMs: executionTime,
+                result: JSON.stringify({ success: false, errorMessage })
+            };
+        }
+    }
+
+    /**
+     * Reassign an agent request to a different user.
+     * Updates RequestForUserID and sends a notification to the new assignee.
+     */
+    @Mutation(() => AIAgentRunResult)
+    async ReassignAgentRequest(
+        @Arg('requestId') requestId: string,
+        @Arg('newUserID') newUserID: string,
+        @Ctx() { userPayload }: AppContext,
+        @Arg('note', { nullable: true }) note?: string
+    ): Promise<AIAgentRunResult> {
+        const startTime = Date.now();
+        try {
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                throw new Error('Unable to determine current user');
+            }
+
+            const md = new Metadata();
+            const request = await md.GetEntityObject<MJAIAgentRequestEntity>(
+                'MJ: AI Agent Requests',
+                currentUser
+            );
+            if (!(await request.Load(requestId))) {
+                throw new Error(`Agent request ${requestId} not found`);
+            }
+
+            if (request.Status !== 'Requested') {
+                throw new Error(`Request ${requestId} is ${request.Status} and cannot be reassigned`);
+            }
+
+            const previousUserID = request.RequestForUserID;
+            request.RequestForUserID = newUserID;
+
+            // Append reassignment note to Comments
+            if (note || previousUserID) {
+                const timestamp = new Date().toISOString();
+                const reassignEntry = `[${timestamp} by ${currentUser.Email || currentUser.ID}] Reassigned from ${previousUserID || '(unassigned)'} to ${newUserID}${note ? ` — "${note}"` : ''}`;
+                request.Comments = request.Comments
+                    ? `${request.Comments}\n${reassignEntry}`
+                    : reassignEntry;
+            }
+
+            const saved = await request.Save();
+            if (!saved) {
+                throw new Error(`Failed to save reassignment for request ${requestId}`);
+            }
+
+            // Send notification to new assignee
+            try {
+                await AIEngine.Instance.Config(false, currentUser);
+                const agent = AIEngine.Instance.Agents.find(a => UUIDsEqual(a.ID, request.AgentID));
+                const agentName = agent?.Name || 'Agent';
+                const truncatedRequest = request.Request.length > 200
+                    ? request.Request.substring(0, 197) + '...'
+                    : request.Request;
+
+                const notificationEngine = NotificationEngine.Instance;
+                await notificationEngine.Config(false, currentUser);
+                await notificationEngine.SendNotification({
+                    userId: newUserID,
+                    typeNameOrId: 'Agent Feedback Request',
+                    title: `${agentName} request assigned to you`,
+                    message: truncatedRequest,
+                    resourceConfiguration: {
+                        type: 'agent-request',
+                        requestId: requestId
+                    }
+                }, currentUser);
+            } catch (notifError) {
+                LogError(`Failed to send reassignment notification: ${(notifError as Error).message}`);
+            }
+
+            LogStatus(`📋 Agent request ${requestId} reassigned to ${newUserID}`);
+
+            const executionTime = Date.now() - startTime;
+            return {
+                success: true,
+                executionTimeMs: executionTime,
+                result: JSON.stringify({
+                    success: true,
+                    requestId,
+                    newUserID,
+                    reassigned: true
+                })
+            };
+        } catch (error) {
+            const executionTime = Date.now() - startTime;
+            const errorMessage = (error as Error).message || 'Unknown error';
+            LogError(`ReassignAgentRequest failed: ${errorMessage}`, undefined, error);
+            return {
+                success: false,
+                errorMessage,
+                executionTimeMs: executionTime,
+                result: JSON.stringify({ success: false, errorMessage })
+            };
+        }
+    }
+
     /**
      * Execute agent in background (fire-and-forget).
      * Handles errors by publishing error completion events via PubSub,