fix: add folderKey

Author: vnaren23

samples/process-app-v0/src/components/ProcessInstances.tsx

@@ -227,7 +227,7 @@ export const ProcessInstances = () => {
     }
 
     try {
-      executionHistory = await sdk.maestro.processes.instances.getExecutionHistory(instance.instanceId);
+      executionHistory = await sdk.maestro.processes.instances.getExecutionHistory(instance.instanceId, instance.folderKey);
     } catch (err) {
       console.error('Error fetching execution history:', err);
       // Continue without execution history

samples/process-app-v1/src/components/ProcessInstances.tsx

@@ -249,7 +249,7 @@ export const ProcessInstances = () => {
 
     try {
       // Use modular ProcessInstances service directly
-      executionHistory = await processInstances.getExecutionHistory(instance.instanceId);
+      executionHistory = await processInstances.getExecutionHistory(instance.instanceId, instance.folderKey);
     } catch (err) {
       console.error('Error fetching execution history:', err);
       // Continue without execution history

src/models/maestro/process-instances.models.ts

@@ -96,13 +96,15 @@ export interface ProcessInstancesServiceModel {
   /**
    * Get execution history (spans) for a process instance
    * @param instanceId The ID of the instance to get history for
+   * @param folderKey The folder key for authorization
    * @returns Promise resolving to execution history
    * {@link ProcessInstanceExecutionHistoryResponse}
    * @example
    * ```typescript
    * // Get execution history for a process instance
    * const history = await processInstances.getExecutionHistory(
-   *   <instanceId>
+   *   <instanceId>,
+   *   <folderKey>
    * );
    *
    * // Analyze execution timeline
@@ -113,7 +115,7 @@ export interface ProcessInstancesServiceModel {
    * });
    * ```
    */
-  getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
+  getExecutionHistory(instanceId: string, folderKey: string): Promise<ProcessInstanceExecutionHistoryResponse[]>;
 
   /**
    * Get BPMN XML file for a process instance
@@ -355,8 +357,9 @@ function createProcessInstanceMethods(instanceData: RawProcessInstanceGetRespons
 
     async getExecutionHistory(): Promise<ProcessInstanceExecutionHistoryResponse[]> {
       if (!instanceData.instanceId) throw new Error('Process instance ID is undefined');
+      if (!instanceData.folderKey) throw new Error('Process instance folder key is undefined');
 
-      return service.getExecutionHistory(instanceData.instanceId);
+      return service.getExecutionHistory(instanceData.instanceId, instanceData.folderKey);
     },
 
     async getBpmn(): Promise<BpmnXmlString> {

src/services/maestro/processes/process-instances.ts

@@ -119,20 +119,27 @@ export class ProcessInstancesService extends BaseService implements ProcessInsta
   /**
    * Get execution history (spans) for a process instance
    * @param instanceId The ID of the instance to get history for
+   * @param folderKey The folder key for authorization
    * @returns Promise<ProcessInstanceExecutionHistoryResponse[]>
    */
   @track('ProcessInstances.GetExecutionHistory')
-  async getExecutionHistory(instanceId: string): Promise<ProcessInstanceExecutionHistoryResponse[]> {
+  async getExecutionHistory(instanceId: string, folderKey: string): Promise<ProcessInstanceExecutionHistoryResponse[]> {
     // Call element-executions API to get structural BPMN data and traceId
     const elementExecResponse = await this.get<ElementExecutionsApiResponse>(
-      MAESTRO_ENDPOINTS.INSTANCES.GET_ELEMENT_EXECUTIONS(instanceId)
+      MAESTRO_ENDPOINTS.INSTANCES.GET_ELEMENT_EXECUTIONS(instanceId),
+      {
+        headers: createHeaders({ [FOLDER_KEY]: folderKey })
+      }
     );
 
     const traceId = elementExecResponse.data.instanceId;
 
     // Call spans API with traceId to get trace/span details
     const spansResponse = await this.get<TraceSpan[]>(
-      MAESTRO_ENDPOINTS.TRACES.GET_SPANS(traceId)
+      MAESTRO_ENDPOINTS.TRACES.GET_SPANS(traceId),
+      {
+        headers: createHeaders({ [FOLDER_KEY]: folderKey })
+      }
     );
 
     // Create span lookup by Id for merging

src/utils/constants/endpoints/maestro.ts

@@ -28,7 +28,7 @@ export const MAESTRO_ENDPOINTS = {
     GET_BY_INSTANCE: (instanceId: string) => `${PIMS_BASE}/api/v1/instances/${instanceId}/incidents`,
   },
   TRACES: {
-    GET_SPANS: (traceId: string) => `${LLMOPS_BASE}api/Traces/spans?traceId=${traceId}`,
+    GET_SPANS: (traceId: string) => `${LLMOPS_BASE}/api/Traces/spans?traceId=${traceId}`,
   },
   CASES: {
     GET_CASE_JSON: (instanceId: string) => `${PIMS_BASE}/api/v1/cases/${instanceId}/case-json`,

tests/integration/shared/maestro/process-instances.integration.test.ts

@@ -249,7 +249,7 @@ describe.each(modes)('Maestro Process Instances - Integration Tests [%s]', (mode
       const { processInstances } = getServices();
 
       try {
-        const result = await processInstances.getExecutionHistory(testInstanceId);
+        const result = await processInstances.getExecutionHistory(testInstanceId, config.folderId || '');
 
         expect(result).toBeDefined();
         expect(Array.isArray(result)).toBe(true);

tests/unit/models/maestro/process-instances.test.ts

@@ -230,19 +230,20 @@ describe('Process Instance Models', () => {
     });
 
     describe('processInstance.getExecutionHistory()', () => {
-      it('should call processInstance.getExecutionHistory with bound instanceId', async () => {
+      it('should call processInstance.getExecutionHistory with bound instanceId and folderKey', async () => {
         const mockInstanceData = createMockProcessInstance();
         const instance = createProcessInstanceWithMethods(mockInstanceData, mockService);
-        
+
         const mockHistory = [createMockExecutionHistory()];
         mockService.getExecutionHistory = vi.fn().mockResolvedValue(mockHistory);
 
-        
+
         const result = await instance.getExecutionHistory();
 
-        
+
         expect(mockService.getExecutionHistory).toHaveBeenCalledWith(
-          MAESTRO_TEST_CONSTANTS.INSTANCE_ID
+          MAESTRO_TEST_CONSTANTS.INSTANCE_ID,
+          MAESTRO_TEST_CONSTANTS.FOLDER_KEY
         );
         expect(result).toEqual(mockHistory);
       });
@@ -252,9 +253,18 @@ describe('Process Instance Models', () => {
         const invalidInstanceData = { ...mockInstanceData, instanceId: undefined as any };
         const invalidInstance = createProcessInstanceWithMethods(invalidInstanceData, mockService);
 
-        
+
         await expect(invalidInstance.getExecutionHistory()).rejects.toThrow('Process instance ID is undefined');
       });
+
+      it('should throw error if folderKey is undefined', async () => {
+        const mockInstanceData = createMockProcessInstance();
+        const invalidInstanceData = { ...mockInstanceData, folderKey: undefined as any };
+        const invalidInstance = createProcessInstanceWithMethods(invalidInstanceData, mockService);
+
+
+        await expect(invalidInstance.getExecutionHistory()).rejects.toThrow('Process instance folder key is undefined');
+      });
     });
 
     describe('processInstance.getBpmn()', () => {

tests/unit/services/maestro/process-instances.test.ts

@@ -210,21 +210,30 @@ describe('ProcessInstancesService', () => {
   describe('getExecutionHistory', () => {
     it('should return execution history for process instance', async () => {
       const instanceId = MAESTRO_TEST_CONSTANTS.INSTANCE_ID;
+      const folderKey = MAESTRO_TEST_CONSTANTS.FOLDER_KEY;
 
       mockApiClient.get
         .mockResolvedValueOnce(createMockElementExecutionsResponse())
         .mockResolvedValueOnce([createMockTraceSpan()]);
 
-      const result = await service.getExecutionHistory(instanceId);
+      const result = await service.getExecutionHistory(instanceId, folderKey);
 
       expect(mockApiClient.get).toHaveBeenCalledWith(
         MAESTRO_ENDPOINTS.INSTANCES.GET_ELEMENT_EXECUTIONS(instanceId),
-        {}
+        {
+          headers: expect.objectContaining({
+            [FOLDER_KEY]: folderKey
+          })
+        }
       );
 
       expect(mockApiClient.get).toHaveBeenCalledWith(
         MAESTRO_ENDPOINTS.TRACES.GET_SPANS(instanceId),
-        {}
+        {
+          headers: expect.objectContaining({
+            [FOLDER_KEY]: folderKey
+          })
+        }
       );
 
       expect(result).toHaveLength(1);
@@ -235,6 +244,7 @@ describe('ProcessInstancesService', () => {
 
     it('should only include spans matched to elementRuns', async () => {
       const instanceId = MAESTRO_TEST_CONSTANTS.INSTANCE_ID;
+      const folderKey = MAESTRO_TEST_CONSTANTS.FOLDER_KEY;
       const unmatchedSpan = createMockTraceSpan({
         Id: 'nested-agent-span-1',
         ParentId: MAESTRO_TEST_CONSTANTS.SPAN_ID,
@@ -246,7 +256,7 @@ describe('ProcessInstancesService', () => {
         .mockResolvedValueOnce(createMockElementExecutionsResponse())
         .mockResolvedValueOnce([createMockTraceSpan(), unmatchedSpan]);
 
-      const result = await service.getExecutionHistory(instanceId);
+      const result = await service.getExecutionHistory(instanceId, folderKey);
 
       // Only the matched elementRun span should be included
       expect(result).toHaveLength(1);
@@ -257,7 +267,7 @@ describe('ProcessInstancesService', () => {
       const error = new Error(TEST_CONSTANTS.ERROR_MESSAGE);
       mockApiClient.get.mockRejectedValue(error);
 
-      await expect(service.getExecutionHistory(MAESTRO_TEST_CONSTANTS.INSTANCE_ID)).rejects.toThrow(TEST_CONSTANTS.ERROR_MESSAGE);
+      await expect(service.getExecutionHistory(MAESTRO_TEST_CONSTANTS.INSTANCE_ID, MAESTRO_TEST_CONSTANTS.FOLDER_KEY)).rejects.toThrow(TEST_CONSTANTS.ERROR_MESSAGE);
     });
   });