feat(feedback): add Feedback.getById method (#405)

* feat(feedback): add Feedback.getById method

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(feedback): improve getById JSDoc examples and param description

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* fix: pass folderkey as header

* fix: set folderkey as options

* fix: integration test

* fix: add validation for folderid

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Sarath1018

docs/oauth-scopes.md

@@ -153,6 +153,7 @@ The `ConversationalAgents` scope is required for real-time WebSocket sessions (`
 | Method | OAuth Scope |
 |--------|-------------|
 | `getAll()` | `Traces.Api` |
+| `getById()` | `Traces.Api` |
 
 ## Processes
 

src/models/agents/feedback/feedback.internal-types.ts

@@ -14,6 +14,7 @@ export interface RawFeedbackGetResponse {
   metadata?: string;
   isPositive: boolean;
   feedbackCategories: FeedbackCategory[];
+  folderKey?: string;
   userEmail?: string;
   status: FeedbackStatus;
   createdAt: string;

src/models/agents/feedback/feedback.models.ts

@@ -1,6 +1,7 @@
 import type {
   FeedbackGetResponse,
   FeedbackGetAllOptions,
+  FeedbackOptions,
 } from './feedback.types';
 import type { PaginatedResponse, NonPaginatedResponse, HasPaginationOptions } from '../../../utils/pagination';
 
@@ -66,4 +67,26 @@ export interface FeedbackServiceModel {
       ? PaginatedResponse<FeedbackGetResponse>
       : NonPaginatedResponse<FeedbackGetResponse>
   >;
+
+  /**
+   * Gets a single feedback entry by its feedback ID.
+   *
+   * @param id - Feedback ID (GUID) of the feedback entry
+   * @param options - Required options including folderKey for folder-level authorization {@link FeedbackOptions}
+   * @returns Promise resolving to {@link FeedbackGetResponse}
+   * @example
+   * ```typescript
+   * import { Feedback } from '@uipath/uipath-typescript/feedback';
+   *
+   * const feedback = new Feedback(sdk);
+   *
+   * // First, get feedback entries to obtain the ID and folder key
+   * const allFeedback = await feedback.getAll({ pageSize: 10 });
+   * const feedbackId = allFeedback.items[0].id;
+   * const folderKey = allFeedback.items[0].folderKey;
+   * const item = await feedback.getById(feedbackId, { folderKey });
+   * console.log(item.isPositive, item.comment, item.status);
+   * ```
+   */
+  getById(id: string, options: FeedbackOptions): Promise<FeedbackGetResponse>;
 }

src/models/agents/feedback/feedback.types.ts

@@ -53,6 +53,8 @@ export interface FeedbackGetResponse {
   isPositive: boolean;
   /** Categories associated with this feedback entry */
   feedbackCategories: FeedbackCategory[];
+  /** Folder key (GUID) of the folder the feedback belongs to */
+  folderKey?: string;
   /** Email address of the user who submitted the feedback */
   userEmail?: string;
   /** Current status of the feedback in the review workflow */
@@ -63,6 +65,14 @@ export interface FeedbackGetResponse {
   updatedTime: string;
 }
 
+/**
+ * Options shared across feedback operations
+ */
+export interface FeedbackOptions {
+  /** Folder key for authorization */
+  folderKey: string;
+}
+
 /**
  * Options for retrieving multiple feedback entries
  */

src/services/agents/feedback/feedback.ts

@@ -2,6 +2,7 @@ import { BaseService } from '../../base';
 import {
   FeedbackGetResponse,
   FeedbackGetAllOptions,
+  FeedbackOptions,
 } from '../../../models/agents/feedback/feedback.types';
 import { FeedbackServiceModel } from '../../../models/agents/feedback/feedback.models';
 import { FeedbackMap } from '../../../models/agents/feedback/feedback.constants';
@@ -13,6 +14,9 @@ import { PaginatedResponse, NonPaginatedResponse, HasPaginationOptions } from '.
 import { PaginationHelpers } from '../../../utils/pagination/helpers';
 import { PaginationType } from '../../../utils/pagination/internal-types';
 import { track } from '../../../core/telemetry';
+import { ValidationError } from '../../../core/errors';
+import { createHeaders } from '../../../utils/http/headers';
+import { FOLDER_KEY } from '../../../utils/constants/headers';
 
 /**
  * Service for interacting with UiPath Agent Feedback API
@@ -81,4 +85,36 @@ export class FeedbackService extends BaseService implements FeedbackServiceModel
       excludeFromPrefix: Object.keys(options || {}),
     }, options);
   }
+
+  /**
+   * Gets a single feedback entry by its feedback ID.
+   *
+   * @param id - Feedback ID (GUID) of the feedback entry
+   * @param options - Required options including folderKey for folder-level authorization {@link FeedbackOptions}
+   * @returns Promise resolving to {@link FeedbackGetResponse}
+   * @example
+   * ```typescript
+   * import { Feedback } from '@uipath/uipath-typescript/feedback';
+   *
+   * const feedback = new Feedback(sdk);
+   *
+   * // First, get feedback entries to obtain the ID and folder key
+   * const allFeedback = await feedback.getAll({ pageSize: 10 });
+   * const feedbackId = allFeedback.items[0].id;
+   * const folderKey = allFeedback.items[0].folderKey;
+   * const item = await feedback.getById(feedbackId, { folderKey });
+   * console.log(item.isPositive, item.comment, item.status);
+   * ```
+   */
+  @track('Feedback.GetById')
+  async getById(id: string, options: FeedbackOptions): Promise<FeedbackGetResponse> {
+    if (!id) throw new ValidationError({ message: 'Feedback ID is required for getById' });
+    if (!options?.folderKey) throw new ValidationError({ message: 'folderKey is required for getById' });
+
+    const response = await this.get<RawFeedbackGetResponse>(
+      FEEDBACK_ENDPOINTS.GET_BY_ID(id),
+      { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) }
+    );
+    return transformData(response.data, FeedbackMap) as unknown as FeedbackGetResponse;
+  }
 }

src/utils/constants/endpoints/feedback.ts

@@ -5,4 +5,5 @@ import { LLMOPS_BASE } from './base';
  */
 export const FEEDBACK_ENDPOINTS = {
   GET_ALL: `${LLMOPS_BASE}/api/Feedback`,
+  GET_BY_ID: (id: string) => `${LLMOPS_BASE}/api/Feedback/${id}`,
 } as const;

tests/integration/shared/agents/feedback.integration.test.ts

@@ -1,7 +1,7 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, beforeAll } from 'vitest';
 import { getServices, setupUnifiedTests, InitMode } from '../../config/unified-setup';
 import { Feedback } from '../../../../src/services/agents/feedback';
-import { FeedbackStatus } from '../../../../src/models/agents/feedback/feedback.types';
+import { FeedbackStatus, FeedbackGetResponse } from '../../../../src/models/agents/feedback/feedback.types';
 
 const modes: InitMode[] = ['v1'];
 
@@ -61,4 +61,51 @@ describe.each(modes)('Agent Feedback - Integration Tests [%s]', (mode) => {
       expect(item.updatedTime).toBeDefined();
     });
   });
+
+  describe('getById', () => {
+    let existingFeedbackId!: string;
+    let existingFolderKey!: string;
+
+    beforeAll(async () => {
+      feedback = getServices().feedback!;
+      const result = await feedback.getAll({ pageSize: 1 });
+      if (result.items.length === 0) {
+        throw new Error('No feedback available for getById tests — create at least one feedback entry first');
+      }
+      existingFeedbackId = result.items[0].id;
+      if (!result.items[0].folderKey) {
+        throw new Error('Feedback entry missing folderKey — cannot run getById tests');
+      }
+      existingFolderKey = result.items[0].folderKey;
+    });
+
+    it('should retrieve feedback by ID', async () => {
+      const result = await feedback.getById(existingFeedbackId, { folderKey: existingFolderKey });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(existingFeedbackId);
+    });
+
+    it('should have expected fields on the retrieved feedback', async () => {
+      const result: FeedbackGetResponse = await feedback.getById(existingFeedbackId, { folderKey: existingFolderKey });
+
+      expect(result.id).toBeDefined();
+      expect(result.traceId).toBeDefined();
+      expect(result.spanId).toBeDefined();
+      expect(typeof result.isPositive).toBe('boolean');
+      expect(Array.isArray(result.feedbackCategories)).toBe(true);
+      expect(result.status).toBeDefined();
+      expect(result.createdTime).toBeDefined();
+      expect(result.updatedTime).toBeDefined();
+    });
+
+    it('should transform API fields — camelCase fields present, raw fields absent', async () => {
+      const result = await feedback.getById(existingFeedbackId, { folderKey: existingFolderKey });
+
+      expect(result.createdTime).toBeDefined();
+      expect(result.updatedTime).toBeDefined();
+      expect((result as any).createdAt).toBeUndefined();
+      expect((result as any).updatedAt).toBeUndefined();
+    });
+  });
 });

tests/unit/services/agents/feedback.test.ts

@@ -92,4 +92,50 @@ describe('FeedbackService Unit Tests', () => {
       );
     });
   });
+
+  describe('getById', () => {
+    it('should get feedback by ID successfully', async () => {
+      const mockResponse = createMockFeedback();
+      mockApiClient.get.mockResolvedValue(mockResponse);
+
+      const result = await feedbackService.getById(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID, { folderKey: FEEDBACK_TEST_CONSTANTS.FOLDER_KEY });
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID);
+      expect(mockApiClient.get).toHaveBeenCalledWith(
+        FEEDBACK_ENDPOINTS.GET_BY_ID(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID),
+        expect.any(Object)
+      );
+    });
+
+    it('should transform createdAt and updatedAt to createdTime and updatedTime', async () => {
+      mockApiClient.get.mockResolvedValue(createMockFeedback());
+
+      const result = await feedbackService.getById(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID, { folderKey: FEEDBACK_TEST_CONSTANTS.FOLDER_KEY });
+
+      expect(result.createdTime).toBe(CONVERSATIONAL_AGENT_TEST_CONSTANTS.CREATED_AT);
+      expect(result.updatedTime).toBe(CONVERSATIONAL_AGENT_TEST_CONSTANTS.UPDATED_AT);
+      expect((result as any).createdAt).toBeUndefined();
+      expect((result as any).updatedAt).toBeUndefined();
+    });
+
+    it('should throw ValidationError when ID is empty', async () => {
+      await expect(feedbackService.getById('', { folderKey: FEEDBACK_TEST_CONSTANTS.FOLDER_KEY })).rejects.toThrow('Feedback ID is required');
+      expect(mockApiClient.get).not.toHaveBeenCalled();
+    });
+
+    it('should throw ValidationError when folderKey is empty', async () => {
+      await expect(feedbackService.getById(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID, { folderKey: '' })).rejects.toThrow('folderKey is required');
+      expect(mockApiClient.get).not.toHaveBeenCalled();
+    });
+
+    it('should throw error when feedback not found', async () => {
+      const error = new Error(FEEDBACK_TEST_CONSTANTS.ERROR_FEEDBACK_NOT_FOUND);
+      mockApiClient.get.mockRejectedValue(error);
+
+      await expect(feedbackService.getById(FEEDBACK_TEST_CONSTANTS.FEEDBACK_ID, { folderKey: FEEDBACK_TEST_CONSTANTS.FOLDER_KEY })).rejects.toThrow(
+        FEEDBACK_TEST_CONSTANTS.ERROR_FEEDBACK_NOT_FOUND
+      );
+    });
+  });
 });

tests/utils/constants/feedback.ts

@@ -7,6 +7,9 @@ export const FEEDBACK_TEST_CONSTANTS = {
   FEEDBACK_ID: 'feedback-1',
   FEEDBACK_ID_2: 'feedback-2',
 
+  // Folder key for authorization
+  FOLDER_KEY: '00000000-0000-0000-0000-000000000001',
+
   // Agent identifiers (string UUID for feedback API)
   AGENT_UUID: 'agent-789',