@memberjunction/server 2.103.0 → 2.105.0

package/src/resolvers/TaskResolver.ts

@@ -0,0 +1,142 @@
+import { Resolver, Mutation, Arg, Ctx, ObjectType, Field, PubSub, PubSubEngine } from 'type-graphql';
+import { AppContext } from '../types.js';
+import { LogError, LogStatus } from '@memberjunction/core';
+import { ResolverBase } from '../generic/ResolverBase.js';
+import { TaskOrchestrator, TaskGraphResponse, TaskExecutionResult } from '../services/TaskOrchestrator.js';
+
+@ObjectType()
+export class TaskExecutionResultType {
+    @Field()
+    taskId: string;
+
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    output?: string;
+
+    @Field({ nullable: true })
+    error?: string;
+}
+
+@ObjectType()
+export class ExecuteTaskGraphResult {
+    @Field()
+    success: boolean;
+
+    @Field({ nullable: true })
+    errorMessage?: string;
+
+    @Field(() => [TaskExecutionResultType])
+    results: TaskExecutionResultType[];
+}
+
+/**
+ * TaskOrchestrationResolver handles multi-step task orchestration.
+ * This resolver is called when the Conversation Manager returns a task graph
+ * for complex workflows that require multiple agents working in sequence or parallel.
+ */
+@Resolver()
+export class TaskOrchestrationResolver extends ResolverBase {
+    /**
+     * Execute a task graph from the Conversation Manager.
+     * This creates tasks in the database, manages dependencies, and executes them in proper order.
+     *
+     * @param taskGraphJson - JSON string containing the task graph from Conversation Manager
+     * @param conversationDetailId - ID of the conversation detail that triggered this workflow
+     * @param environmentId - Environment ID for the tasks
+     */
+    @Mutation(() => ExecuteTaskGraphResult)
+    async ExecuteTaskGraph(
+        @Arg('taskGraphJson') taskGraphJson: string,
+        @Arg('conversationDetailId') conversationDetailId: string,
+        @Arg('environmentId') environmentId: string,
+        @Arg('sessionId') sessionId: string,
+        @PubSub() pubSub: PubSubEngine,
+        @Ctx() { userPayload }: AppContext
+    ): Promise<ExecuteTaskGraphResult> {
+        try {
+            LogStatus(`=== EXECUTING TASK GRAPH FOR CONVERSATION: ${conversationDetailId} ===`);
+
+            // Parse task graph
+            const taskGraph: TaskGraphResponse = JSON.parse(taskGraphJson);
+
+            // Validate task graph
+            if (!taskGraph.workflowName || !taskGraph.tasks || taskGraph.tasks.length === 0) {
+                throw new Error('Invalid task graph: must have workflowName and at least one task');
+            }
+
+            // Get current user
+            const currentUser = this.GetUserFromPayload(userPayload);
+            if (!currentUser) {
+                throw new Error('Unable to determine current user');
+            }
+
+            LogStatus(`Workflow: ${taskGraph.workflowName} (${taskGraph.tasks.length} tasks)`);
+            if (taskGraph.reasoning) {
+                LogStatus(`Reasoning: ${taskGraph.reasoning}`);
+            }
+
+            // Create task orchestrator with PubSub for progress updates
+            const orchestrator = new TaskOrchestrator(currentUser, pubSub, sessionId, userPayload);
+
+            // Create parent task and child tasks with dependencies
+            const { parentTaskId, taskIdMap } = await orchestrator.createTasksFromGraph(
+                taskGraph,
+                conversationDetailId,
+                environmentId
+            );
+
+            LogStatus(`Created parent task ${parentTaskId} with ${taskIdMap.size} child tasks`);
+
+            // Execute tasks in proper order
+            const results = await orchestrator.executeTasksForParent(
+                parentTaskId
+            );
+
+            // Log results
+            const successCount = results.filter(r => r.success).length;
+            LogStatus(`Completed ${successCount} of ${results.length} tasks successfully`);
+
+            for (const result of results) {
+                if (result.success) {
+                    LogStatus(`✅ Task ${result.taskId} completed successfully`);
+                } else {
+                    LogError(`❌ Task ${result.taskId} failed: ${result.error}`);
+                }
+            }
+
+            // Convert results to GraphQL types
+            const graphqlResults: TaskExecutionResultType[] = results.map(r => ({
+                taskId: r.taskId,
+                success: r.success,
+                output: r.output ? JSON.stringify(r.output) : undefined,
+                error: r.error
+            }));
+
+            LogStatus(`=== TASK GRAPH EXECUTION COMPLETE ===`);
+
+            const result = {
+                success: true,
+                results: graphqlResults
+            };
+
+            LogStatus(`Returning ExecuteTaskGraph result: ${JSON.stringify({
+                success: result.success,
+                resultsCount: result.results.length,
+                firstResult: result.results[0]
+            })}`);
+
+            return result;
+
+        } catch (error) {
+            LogError(`Task graph execution failed:`, undefined, error);
+
+            return {
+                success: false,
+                errorMessage: (error as Error).message || 'Unknown error occurred',
+                results: []
+            };
+        }
+    }
+}

package/src/resolvers/UserFavoriteResolver.ts

@@ -15,7 +15,7 @@ import {
 } from '@memberjunction/server';
 import { UserCache } from '@memberjunction/sqlserver-dataprovider';
 
-import { UserFavorite_, UserFavoriteResolverBase } from '../generated/generated.js';
+import { MJUserFavorite_, MJUserFavoriteResolverBase } from '../generated/generated.js';
 import { GetReadOnlyProvider } from '../util.js';
 
 //****************************************************************************
@@ -66,15 +66,15 @@ export class UserFavoriteResult {
   Success: boolean;
 }
 
-@Resolver(UserFavorite_)
-export class UserFavoriteResolver extends UserFavoriteResolverBase {
-  @Query(() => [UserFavorite_])
+@Resolver(MJUserFavorite_)
+export class UserFavoriteResolver extends MJUserFavoriteResolverBase {
+  @Query(() => [MJUserFavorite_])
   async UserFavoritesByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { providers, userPayload }: AppContext) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     return await this.findBy(provider, 'User Favorites', { UserID }, userPayload.userRecord);
   }
 
-  @Query(() => [UserFavorite_])
+  @Query(() => [MJUserFavorite_])
   async UserFavoriteSearchByParams(@Arg('params', () => Int) params: UserFavoriteSearchParams, @Ctx() { providers, userPayload }: AppContext) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     return await this.findBy(provider, 'User Favorites', params, userPayload.userRecord);

package/src/resolvers/UserResolver.ts

@@ -1,31 +1,31 @@
 import { AppContext, Arg, Ctx, Int, Query, Resolver } from '@memberjunction/server';
-import { User_, UserResolverBase } from '../generated/generated.js';
+import { MJUser_, MJUserResolverBase } from '../generated/generated.js';
 import { GetReadOnlyProvider } from '../util.js';
 
-@Resolver(User_)
-export class UserResolver extends UserResolverBase {
-  @Query(() => User_)
+@Resolver(MJUser_)
+export class UserResolver extends MJUserResolverBase {
+  @Query(() => MJUser_)
   async CurrentUser(@Ctx() context: AppContext) {
     const result = await this.UserByEmail(context.userPayload.email, context);
     console.log('CurrentUser', result);
     return result;
   }
 
-  @Query(() => User_)
+  @Query(() => MJUser_)
   async UserByID(@Arg('ID', () => Int) ID: number, @Ctx() { providers, userPayload }: AppContext) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { ID }, userPayload.userRecord));
     return this.MapFieldNamesToCodeNames('Users', retVal);
   }
 
-  @Query(() => User_)
+  @Query(() => MJUser_)
   async UserByEmployeeID(@Arg('EmployeeID', () => Int) EmployeeID: number, @Ctx() { providers, userPayload }: AppContext) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     const retVal = super.safeFirstArrayElement(await this.findBy(provider, 'Users', { EmployeeID }, userPayload.userRecord));
     return this.MapFieldNamesToCodeNames('Users', retVal);
   }
 
-  @Query(() => User_)
+  @Query(() => MJUser_)
   async UserByEmail(@Arg('Email', () => String) Email: string, @Ctx() { providers, userPayload }: AppContext) {
     // const searchEmail = userEmailMap[Email] ?? Email;
     const searchEmail = Email;

package/src/resolvers/UserViewResolver.ts

@@ -1,20 +1,20 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { EntitySaveOptions, Metadata } from '@memberjunction/core';
 import { AppContext, Arg, Ctx, Int, Query, Resolver, UserPayload } from '@memberjunction/server';
-import { UserView_, UserViewResolverBase } from '../generated/generated.js';
+import { MJUserView_, MJUserViewResolverBase } from '../generated/generated.js';
 import { UserResolver } from './UserResolver.js';
 import { UserViewEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
 import { GetReadOnlyProvider } from '../util.js';
 
-@Resolver(UserView_)
-export class UserViewResolver extends UserViewResolverBase {
-  @Query(() => [UserView_])
+@Resolver(MJUserView_)
+export class UserViewResolver extends MJUserViewResolverBase {
+  @Query(() => [MJUserView_])
   async UserViewsByUserID(@Arg('UserID', () => Int) UserID: number, @Ctx() { providers, userPayload }: AppContext) {
     const provider = GetReadOnlyProvider(providers, {allowFallbackToReadWrite: true})    
     return await this.findBy(provider, 'User Views', { UserID }, userPayload.userRecord);
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async DefaultViewByUserAndEntity(
     @Arg('UserID', () => Int) UserID: number,
     @Arg('EntityID', () => Int) EntityID: number,
@@ -24,7 +24,7 @@ export class UserViewResolver extends UserViewResolverBase {
     return await this.findBy(provider, 'User Views', { UserID, EntityID, IsDefault: true }, userPayload.userRecord);
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async CurrentUserDefaultViewByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
     return await this.findBy(provider, 'User Views', {
@@ -40,13 +40,13 @@ export class UserViewResolver extends UserViewResolverBase {
     return user.ID;
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async CurrentUserUserViewsByEntityID(@Arg('EntityID', () => Int) EntityID: number, @Ctx() context: AppContext) {
     const provider = GetReadOnlyProvider(context.providers, {allowFallbackToReadWrite: true})    
     return this.findBy(provider, 'User Views', { UserID: await this.getCurrentUserID(context), EntityID}, context.userPayload.userRecord);
   }
 
-  @Query(() => [UserView_])
+  @Query(() => [MJUserView_])
   async UpdateWhereClause(@Arg('ID', () => String) ID: string, @Ctx() { userPayload, providers }: AppContext) {
     // in this query we want to update the uesrView record in the DB with a new where clause
     // this should normally not be a factor but we have this exposed in the GraphQL API so that

package/src/services/TaskOrchestration-Integration.md

@@ -0,0 +1,188 @@
+# Task Orchestration Integration Guide
+
+## Overview
+This document explains how to integrate the TaskOrchestrator into the Conversation Manager agent flow.
+
+## Components Created
+
+1. **TaskOrchestrator** (`/services/TaskOrchestrator.ts`)
+   - Creates tasks from LLM task graphs
+   - Manages task dependencies
+   - Executes tasks in proper order
+   - Passes outputs between tasks
+
+2. **Updated Conversation Manager Prompt** (`/metadata/prompts/templates/conversations/conversation-manager-agent.template.md`)
+   - Now supports returning task graphs
+   - Backward compatible with simple agent delegation
+
+## Integration Points
+
+### 1. Where to Add Task Orchestration Logic
+
+When the Conversation Manager agent returns a response, check the `payloadChangeRequest.newElements` for either:
+
+**Simple delegation (existing):**
+```typescript
+if (newElements.invokeAgent) {
+    // Existing flow - delegate to single agent
+    const agentName = newElements.invokeAgent;
+    // ... invoke agent ...
+}
+```
+
+**Multi-step orchestration (new):**
+```typescript
+if (newElements.taskGraph) {
+    const taskGraph = newElements.taskGraph;
+
+    if (taskGraph.isMultiStep) {
+        // Create tasks in database
+        const orchestrator = new TaskOrchestrator(contextUser);
+        const taskIdMap = await orchestrator.createTasksFromGraph(
+            taskGraph,
+            conversationDetailId,
+            environmentId
+        );
+
+        // Execute tasks (respecting dependencies)
+        const results = await orchestrator.executeTasksForConversation(
+            conversationDetailId
+        );
+
+        // Send results back to conversation
+        // ... format and return results ...
+    }
+}
+```
+
+### 2. Suggested Integration Location
+
+**Option A: In RunAIAgent Resolver**
+- File: `/packages/MJServer/src/resolvers/RunAIAgentResolver.ts`
+- After agent execution, check the result payload for taskGraph
+- Create and execute tasks if multi-step
+
+**Option B: In AskSkip Resolver**
+- File: `/packages/MJServer/src/resolvers/AskSkipResolver.ts`
+- When processing conversation manager responses
+- Check for taskGraph in the response payload
+
+**Option C: New Task Resolver (Recommended)**
+- Create `/packages/MJServer/src/resolvers/TaskResolver.ts`
+- Add mutation: `ExecuteTaskGraph(taskGraph, conversationDetailId, environmentId)`
+- Keep task orchestration logic separate and reusable
+
+### 3. Example Integration Code
+
+```typescript
+import { TaskOrchestrator, TaskGraphResponse } from '../services/TaskOrchestrator.js';
+
+// In your resolver after Conversation Manager responds
+async handleConversationManagerResponse(
+    agentResult: ExecuteAgentResult,
+    conversationDetailId: string,
+    environmentId: string,
+    contextUser: UserInfo
+): Promise<void> {
+    // Check if response contains a task graph
+    if (agentResult.payload?.taskGraph) {
+        const taskGraph: TaskGraphResponse = agentResult.payload.taskGraph;
+
+        if (taskGraph.isMultiStep) {
+            LogStatus(`Multi-step workflow detected: ${taskGraph.tasks.length} tasks`);
+
+            // Create task orchestrator
+            const orchestrator = new TaskOrchestrator(contextUser);
+
+            // Create tasks and dependencies
+            const taskIdMap = await orchestrator.createTasksFromGraph(
+                taskGraph,
+                conversationDetailId,
+                environmentId
+            );
+
+            LogStatus(`Created ${taskIdMap.size} tasks with dependencies`);
+
+            // Execute tasks in proper order
+            const results = await orchestrator.executeTasksForConversation(
+                conversationDetailId
+            );
+
+            // Log results
+            for (const result of results) {
+                if (result.success) {
+                    LogStatus(`Task ${result.taskId} completed successfully`);
+                } else {
+                    LogError(`Task ${result.taskId} failed: ${result.error}`);
+                }
+            }
+
+            // Return task completion summary to user
+            return {
+                success: true,
+                message: `Completed ${results.filter(r => r.success).length} of ${results.length} tasks`,
+                results: results
+            };
+        }
+    }
+
+    // Simple agent delegation (existing flow)
+    if (agentResult.payload?.invokeAgent) {
+        // ... existing single-agent delegation logic ...
+    }
+}
+```
+
+### 4. UI Integration
+
+The existing task UI components already work with TaskEntity:
+- `/packages/Angular/Generic/conversations/src/lib/components/task/task-list.component.ts`
+- Tasks will automatically appear in the task list
+- Users can see progress, dependencies, and results
+
+### 5. Testing
+
+**Test Single-Step (Backward Compatibility):**
+```
+User: "Analyze our sales data"
+Expected: Conversation Manager delegates to Analysis Agent (existing behavior)
+```
+
+**Test Multi-Step:**
+```
+User: "Research associations with 5-30M revenue in USA, then create a GTM report"
+Expected:
+- Conversation Manager returns taskGraph
+- Task 1 (Research) executes
+- Task 2 (GTM Report) waits for Task 1
+- Task 2 receives Task 1 output
+- Both complete successfully
+```
+
+## Database Schema
+
+No changes needed! TaskEntity and TaskDependencyEntity already exist with all required fields.
+
+**Note:** For production, consider adding these optional columns to Task table:
+- `InputPayload` NVARCHAR(MAX) - Better than embedding in Description
+- `OutputPayload` NVARCHAR(MAX) - Better than embedding in Description
+
+Current implementation uses Description field with `__TASK_METADATA__` and `__TASK_OUTPUT__` markers as a workaround.
+
+## Future Enhancements
+
+1. **Parallel Execution**: Modify executeTasksForConversation() to run independent tasks concurrently
+2. **Progress Streaming**: Use WebSockets to stream task progress to UI
+3. **Task Templates**: Save common workflows as reusable templates
+4. **Error Recovery**: Add retry logic and error handling strategies
+5. **Task Cancellation**: Allow users to cancel in-progress task chains
+6. **Visualization**: Show task dependency graph in UI
+
+## Questions?
+
+- TaskOrchestrator handles all task lifecycle management
+- Conversation Manager LLM determines when to use multi-step
+- Existing UI components display tasks automatically
+- Fully backward compatible with simple delegation
+
+Integration should take ~1-2 hours for experienced developer familiar with the codebase.