@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/human-review.d.ts

@@ -0,0 +1,275 @@
+/**
+ * ThinkHive SDK v3.0 - Human Review API
+ *
+ * API for managing human review queue, calibration sets, and reviewer management
+ */
+export type HumanReviewStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'expired';
+export type HumanReviewType = 'disagreement' | 'low_confidence' | 'calibration' | 'random_sample' | 'flagged';
+export interface HumanReviewQueueItem {
+    id: string;
+    companyId: string;
+    agentId: string;
+    traceId: string;
+    criterionId?: string;
+    reviewType: HumanReviewType;
+    priority: number;
+    status: HumanReviewStatus;
+    llmScore?: number;
+    llmPassed?: boolean;
+    llmReasoning?: string;
+    llmConfidence?: number;
+    reviewerId?: string;
+    humanScore?: number;
+    humanPassed?: boolean;
+    humanReasoning?: string;
+    reviewDurationMs?: number;
+    isCalibrationSample?: boolean;
+    calibrationSetId?: string;
+    expectedScore?: number;
+    expectedPassed?: boolean;
+    expiresAt?: string;
+    claimedAt?: string;
+    completedAt?: string;
+    createdAt: string;
+}
+export interface AddToQueueOptions {
+    traceId: string;
+    criterionId?: string;
+    agentId: string;
+    reviewType: HumanReviewType;
+    priority?: number;
+    llmScore?: number;
+    llmPassed?: boolean;
+    llmReasoning?: string;
+    llmConfidence?: number;
+    isCalibrationSample?: boolean;
+    calibrationSetId?: string;
+    expectedScore?: number;
+    expectedPassed?: boolean;
+    expiresInMs?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SubmitReviewOptions {
+    passed: boolean;
+    score: number;
+    reasoning: string;
+    durationMs: number;
+}
+export interface CalibrationSet {
+    id: string;
+    companyId: string;
+    agentId?: string;
+    name: string;
+    description?: string;
+    targetSampleCount: number;
+    currentSampleCount: number;
+    minAgreementRate: number;
+    passingScoreThreshold: number;
+    criteriaIds: string[];
+    isActive: boolean;
+    createdBy?: string;
+    createdAt: string;
+}
+export interface CreateCalibrationSetOptions {
+    name: string;
+    description?: string;
+    agentId: string;
+    criterionId?: string;
+    targetAgreement?: number;
+    minSamples?: number;
+}
+export interface ReviewerCalibration {
+    id: string;
+    userId: string;
+    calibrationSetId: string;
+    totalReviews: number;
+    agreementRate: number;
+    meanAbsoluteError: number;
+    isCertified: boolean;
+    certifiedAt?: string;
+    lastReviewAt?: string;
+}
+export interface QueueStats {
+    pending: number;
+    inProgress: number;
+    completed: number;
+    skipped: number;
+    expired: number;
+    avgReviewDurationMs?: number;
+    avgAgreementRate?: number;
+}
+export interface ListQueueOptions {
+    agentId?: string;
+    status?: HumanReviewStatus;
+    reviewType?: HumanReviewType;
+    isCalibration?: boolean;
+    minPriority?: number;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Human Review API client for managing human review queue and calibration
+ */
+export declare const humanReview: {
+    /**
+     * Get pending review queue items
+     *
+     * @example
+     * ```typescript
+     * const items = await humanReview.getQueue({
+     *   agentId: 'agent_123',
+     *   status: 'pending',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    getQueue(options?: ListQueueOptions): Promise<HumanReviewQueueItem[]>;
+    /**
+     * Add an item to the review queue
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.addToQueue({
+     *   traceId: 'trace_123',
+     *   agentId: 'agent_123',
+     *   reviewType: 'disagreement',
+     *   priority: 80,
+     *   llmScore: 65,
+     *   llmPassed: true,
+     * });
+     * ```
+     */
+    addToQueue(options: AddToQueueOptions): Promise<HumanReviewQueueItem>;
+    /**
+     * Get a specific review item
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.getItem('item_123');
+     * ```
+     */
+    getItem(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Claim a review item for processing
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.claim('item_123');
+     * ```
+     */
+    claim(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Release a claimed review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.release('item_123');
+     * ```
+     */
+    release(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Skip a review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.skip('item_123');
+     * ```
+     */
+    skip(itemId: string): Promise<HumanReviewQueueItem>;
+    /**
+     * Submit a review
+     *
+     * @example
+     * ```typescript
+     * const result = await humanReview.submit('item_123', {
+     *   passed: true,
+     *   score: 85,
+     *   reasoning: 'Response accurately addressed the query',
+     *   durationMs: 45000,
+     * });
+     * ```
+     */
+    submit(itemId: string, review: SubmitReviewOptions): Promise<HumanReviewQueueItem>;
+    /**
+     * Get queue statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await humanReview.getStats('agent_123');
+     * ```
+     */
+    getStats(agentId?: string): Promise<QueueStats>;
+    /**
+     * Get next item for a reviewer
+     *
+     * @example
+     * ```typescript
+     * const nextItem = await humanReview.getNextItem('agent_123');
+     * ```
+     */
+    getNextItem(agentId?: string): Promise<HumanReviewQueueItem | null>;
+    /**
+     * Get available review types
+     *
+     * @example
+     * ```typescript
+     * const types = await humanReview.getReviewTypes();
+     * ```
+     */
+    getReviewTypes(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        autoTrigger: boolean;
+    }>>;
+    /**
+     * Get calibration sets
+     *
+     * @example
+     * ```typescript
+     * const sets = await humanReview.getCalibrationSets('agent_123');
+     * ```
+     */
+    getCalibrationSets(agentId?: string): Promise<CalibrationSet[]>;
+    /**
+     * Create a calibration set
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.createCalibrationSet({
+     *   name: 'Quality Calibration Q1',
+     *   agentId: 'agent_123',
+     *   targetAgreement: 0.85,
+     *   minSamples: 50,
+     * });
+     * ```
+     */
+    createCalibrationSet(options: CreateCalibrationSetOptions): Promise<CalibrationSet>;
+    /**
+     * Get a calibration set by ID
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.getCalibrationSet('set_123');
+     * ```
+     */
+    getCalibrationSet(setId: string): Promise<CalibrationSet>;
+    /**
+     * Get certified reviewers for a calibration set
+     *
+     * @example
+     * ```typescript
+     * const reviewers = await humanReview.getCertifiedReviewers('set_123');
+     * ```
+     */
+    getCertifiedReviewers(calibrationSetId: string): Promise<ReviewerCalibration[]>;
+    /**
+     * Get reviewer calibration status
+     *
+     * @example
+     * ```typescript
+     * const calibrations = await humanReview.getReviewerCalibrations('user_123');
+     * ```
+     */
+    getReviewerCalibrations(userId: string): Promise<ReviewerCalibration[]>;
+};

package/dist/api/human-review.js

@@ -0,0 +1,236 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Human Review API
+ *
+ * API for managing human review queue, calibration sets, and reviewer management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humanReview = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// HUMAN REVIEW API CLIENT
+// ============================================================================
+/**
+ * Human Review API client for managing human review queue and calibration
+ */
+exports.humanReview = {
+    /**
+     * Get pending review queue items
+     *
+     * @example
+     * ```typescript
+     * const items = await humanReview.getQueue({
+     *   agentId: 'agent_123',
+     *   status: 'pending',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    async getQueue(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agentId)
+            params.set('agentId', options.agentId);
+        if (options.status)
+            params.set('status', options.status);
+        if (options.reviewType)
+            params.set('reviewType', options.reviewType);
+        if (options.isCalibration !== undefined)
+            params.set('isCalibration', String(options.isCalibration));
+        if (options.minPriority !== undefined)
+            params.set('minPriority', String(options.minPriority));
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.offset)
+            params.set('offset', String(options.offset));
+        return (0, client_1.apiRequestWithData)(`/human-review/queue?${params.toString()}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Add an item to the review queue
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.addToQueue({
+     *   traceId: 'trace_123',
+     *   agentId: 'agent_123',
+     *   reviewType: 'disagreement',
+     *   priority: 80,
+     *   llmScore: 65,
+     *   llmPassed: true,
+     * });
+     * ```
+     */
+    async addToQueue(options) {
+        return (0, client_1.apiRequestWithData)('/human-review/queue', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get a specific review item
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.getItem('item_123');
+     * ```
+     */
+    async getItem(itemId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/queue/${itemId}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Claim a review item for processing
+     *
+     * @example
+     * ```typescript
+     * const item = await humanReview.claim('item_123');
+     * ```
+     */
+    async claim(itemId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/queue/${itemId}/claim`, { method: 'POST', apiVersion: 'v1' });
+    },
+    /**
+     * Release a claimed review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.release('item_123');
+     * ```
+     */
+    async release(itemId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/queue/${itemId}/release`, { method: 'POST', apiVersion: 'v1' });
+    },
+    /**
+     * Skip a review item
+     *
+     * @example
+     * ```typescript
+     * await humanReview.skip('item_123');
+     * ```
+     */
+    async skip(itemId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/queue/${itemId}/skip`, { method: 'POST', apiVersion: 'v1' });
+    },
+    /**
+     * Submit a review
+     *
+     * @example
+     * ```typescript
+     * const result = await humanReview.submit('item_123', {
+     *   passed: true,
+     *   score: 85,
+     *   reasoning: 'Response accurately addressed the query',
+     *   durationMs: 45000,
+     * });
+     * ```
+     */
+    async submit(itemId, review) {
+        return (0, client_1.apiRequestWithData)(`/human-review/queue/${itemId}/submit`, { method: 'POST', body: review, apiVersion: 'v1' });
+    },
+    /**
+     * Get queue statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = await humanReview.getStats('agent_123');
+     * ```
+     */
+    async getStats(agentId) {
+        const params = agentId ? `?agentId=${agentId}` : '';
+        return (0, client_1.apiRequestWithData)(`/human-review/stats${params}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get next item for a reviewer
+     *
+     * @example
+     * ```typescript
+     * const nextItem = await humanReview.getNextItem('agent_123');
+     * ```
+     */
+    async getNextItem(agentId) {
+        const params = agentId ? `?agentId=${agentId}` : '';
+        return (0, client_1.apiRequestWithData)(`/human-review/next-item${params}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get available review types
+     *
+     * @example
+     * ```typescript
+     * const types = await humanReview.getReviewTypes();
+     * ```
+     */
+    async getReviewTypes() {
+        return (0, client_1.apiRequestWithData)('/human-review/review-types', { apiVersion: 'v1' });
+    },
+    // ---------------------------------------------------------------------------
+    // CALIBRATION SETS
+    // ---------------------------------------------------------------------------
+    /**
+     * Get calibration sets
+     *
+     * @example
+     * ```typescript
+     * const sets = await humanReview.getCalibrationSets('agent_123');
+     * ```
+     */
+    async getCalibrationSets(agentId) {
+        const params = agentId ? `?agentId=${agentId}` : '';
+        return (0, client_1.apiRequestWithData)(`/human-review/calibration-sets${params}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Create a calibration set
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.createCalibrationSet({
+     *   name: 'Quality Calibration Q1',
+     *   agentId: 'agent_123',
+     *   targetAgreement: 0.85,
+     *   minSamples: 50,
+     * });
+     * ```
+     */
+    async createCalibrationSet(options) {
+        return (0, client_1.apiRequestWithData)('/human-review/calibration-sets', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get a calibration set by ID
+     *
+     * @example
+     * ```typescript
+     * const set = await humanReview.getCalibrationSet('set_123');
+     * ```
+     */
+    async getCalibrationSet(setId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/calibration-sets/${setId}`, { apiVersion: 'v1' });
+    },
+    // ---------------------------------------------------------------------------
+    // REVIEWER CALIBRATION
+    // ---------------------------------------------------------------------------
+    /**
+     * Get certified reviewers for a calibration set
+     *
+     * @example
+     * ```typescript
+     * const reviewers = await humanReview.getCertifiedReviewers('set_123');
+     * ```
+     */
+    async getCertifiedReviewers(calibrationSetId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/reviewers?calibrationSetId=${calibrationSetId}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get reviewer calibration status
+     *
+     * @example
+     * ```typescript
+     * const calibrations = await humanReview.getReviewerCalibrations('user_123');
+     * ```
+     */
+    async getReviewerCalibrations(userId) {
+        return (0, client_1.apiRequestWithData)(`/human-review/calibration/${userId}`, { apiVersion: 'v1' });
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"human-review.js","sourceRoot":"","sources":["../../src/api/human-review.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Human Review API\n *\n * API for managing human review queue, calibration sets, and reviewer management\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type HumanReviewStatus = 'pending' | 'in_progress' | 'completed' | 'skipped' | 'expired';\nexport type HumanReviewType = 'disagreement' | 'low_confidence' | 'calibration' | 'random_sample' | 'flagged';\n\nexport interface HumanReviewQueueItem {\n  id: string;\n  companyId: string;\n  agentId: string;\n  traceId: string;\n  criterionId?: string;\n  reviewType: HumanReviewType;\n  priority: number;\n  status: HumanReviewStatus;\n  llmScore?: number;\n  llmPassed?: boolean;\n  llmReasoning?: string;\n  llmConfidence?: number;\n  reviewerId?: string;\n  humanScore?: number;\n  humanPassed?: boolean;\n  humanReasoning?: string;\n  reviewDurationMs?: number;\n  isCalibrationSample?: boolean;\n  calibrationSetId?: string;\n  expectedScore?: number;\n  expectedPassed?: boolean;\n  expiresAt?: string;\n  claimedAt?: string;\n  completedAt?: string;\n  createdAt: string;\n}\n\nexport interface AddToQueueOptions {\n  traceId: string;\n  criterionId?: string;\n  agentId: string;\n  reviewType: HumanReviewType;\n  priority?: number;\n  llmScore?: number;\n  llmPassed?: boolean;\n  llmReasoning?: string;\n  llmConfidence?: number;\n  isCalibrationSample?: boolean;\n  calibrationSetId?: string;\n  expectedScore?: number;\n  expectedPassed?: boolean;\n  expiresInMs?: number;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface SubmitReviewOptions {\n  passed: boolean;\n  score: number;\n  reasoning: string;\n  durationMs: number;\n}\n\nexport interface CalibrationSet {\n  id: string;\n  companyId: string;\n  agentId?: string;\n  name: string;\n  description?: string;\n  targetSampleCount: number;\n  currentSampleCount: number;\n  minAgreementRate: number;\n  passingScoreThreshold: number;\n  criteriaIds: string[];\n  isActive: boolean;\n  createdBy?: string;\n  createdAt: string;\n}\n\nexport interface CreateCalibrationSetOptions {\n  name: string;\n  description?: string;\n  agentId: string;\n  criterionId?: string;\n  targetAgreement?: number;\n  minSamples?: number;\n}\n\nexport interface ReviewerCalibration {\n  id: string;\n  userId: string;\n  calibrationSetId: string;\n  totalReviews: number;\n  agreementRate: number;\n  meanAbsoluteError: number;\n  isCertified: boolean;\n  certifiedAt?: string;\n  lastReviewAt?: string;\n}\n\nexport interface QueueStats {\n  pending: number;\n  inProgress: number;\n  completed: number;\n  skipped: number;\n  expired: number;\n  avgReviewDurationMs?: number;\n  avgAgreementRate?: number;\n}\n\nexport interface ListQueueOptions {\n  agentId?: string;\n  status?: HumanReviewStatus;\n  reviewType?: HumanReviewType;\n  isCalibration?: boolean;\n  minPriority?: number;\n  limit?: number;\n  offset?: number;\n}\n\n// ============================================================================\n// HUMAN REVIEW API CLIENT\n// ============================================================================\n\n/**\n * Human Review API client for managing human review queue and calibration\n */\nexport const humanReview = {\n  /**\n   * Get pending review queue items\n   *\n   * @example\n   * ```typescript\n   * const items = await humanReview.getQueue({\n   *   agentId: 'agent_123',\n   *   status: 'pending',\n   *   limit: 20,\n   * });\n   * ```\n   */\n  async getQueue(options: ListQueueOptions = {}): Promise<HumanReviewQueueItem[]> {\n    const params = new URLSearchParams();\n    if (options.agentId) params.set('agentId', options.agentId);\n    if (options.status) params.set('status', options.status);\n    if (options.reviewType) params.set('reviewType', options.reviewType);\n    if (options.isCalibration !== undefined) params.set('isCalibration', String(options.isCalibration));\n    if (options.minPriority !== undefined) params.set('minPriority', String(options.minPriority));\n    if (options.limit) params.set('limit', String(options.limit));\n    if (options.offset) params.set('offset', String(options.offset));\n\n    return apiRequestWithData<HumanReviewQueueItem[]>(\n      `/human-review/queue?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Add an item to the review queue\n   *\n   * @example\n   * ```typescript\n   * const item = await humanReview.addToQueue({\n   *   traceId: 'trace_123',\n   *   agentId: 'agent_123',\n   *   reviewType: 'disagreement',\n   *   priority: 80,\n   *   llmScore: 65,\n   *   llmPassed: true,\n   * });\n   * ```\n   */\n  async addToQueue(options: AddToQueueOptions): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>('/human-review/queue', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get a specific review item\n   *\n   * @example\n   * ```typescript\n   * const item = await humanReview.getItem('item_123');\n   * ```\n   */\n  async getItem(itemId: string): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>(\n      `/human-review/queue/${itemId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Claim a review item for processing\n   *\n   * @example\n   * ```typescript\n   * const item = await humanReview.claim('item_123');\n   * ```\n   */\n  async claim(itemId: string): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>(\n      `/human-review/queue/${itemId}/claim`,\n      { method: 'POST', apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Release a claimed review item\n   *\n   * @example\n   * ```typescript\n   * await humanReview.release('item_123');\n   * ```\n   */\n  async release(itemId: string): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>(\n      `/human-review/queue/${itemId}/release`,\n      { method: 'POST', apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Skip a review item\n   *\n   * @example\n   * ```typescript\n   * await humanReview.skip('item_123');\n   * ```\n   */\n  async skip(itemId: string): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>(\n      `/human-review/queue/${itemId}/skip`,\n      { method: 'POST', apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Submit a review\n   *\n   * @example\n   * ```typescript\n   * const result = await humanReview.submit('item_123', {\n   *   passed: true,\n   *   score: 85,\n   *   reasoning: 'Response accurately addressed the query',\n   *   durationMs: 45000,\n   * });\n   * ```\n   */\n  async submit(itemId: string, review: SubmitReviewOptions): Promise<HumanReviewQueueItem> {\n    return apiRequestWithData<HumanReviewQueueItem>(\n      `/human-review/queue/${itemId}/submit`,\n      { method: 'POST', body: review, apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get queue statistics\n   *\n   * @example\n   * ```typescript\n   * const stats = await humanReview.getStats('agent_123');\n   * ```\n   */\n  async getStats(agentId?: string): Promise<QueueStats> {\n    const params = agentId ? `?agentId=${agentId}` : '';\n    return apiRequestWithData<QueueStats>(\n      `/human-review/stats${params}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get next item for a reviewer\n   *\n   * @example\n   * ```typescript\n   * const nextItem = await humanReview.getNextItem('agent_123');\n   * ```\n   */\n  async getNextItem(agentId?: string): Promise<HumanReviewQueueItem | null> {\n    const params = agentId ? `?agentId=${agentId}` : '';\n    return apiRequestWithData<HumanReviewQueueItem | null>(\n      `/human-review/next-item${params}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get available review types\n   *\n   * @example\n   * ```typescript\n   * const types = await humanReview.getReviewTypes();\n   * ```\n   */\n  async getReviewTypes(): Promise<Array<{\n    id: string;\n    name: string;\n    description: string;\n    autoTrigger: boolean;\n  }>> {\n    return apiRequestWithData('/human-review/review-types', { apiVersion: 'v1' });\n  },\n\n  // ---------------------------------------------------------------------------\n  // CALIBRATION SETS\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get calibration sets\n   *\n   * @example\n   * ```typescript\n   * const sets = await humanReview.getCalibrationSets('agent_123');\n   * ```\n   */\n  async getCalibrationSets(agentId?: string): Promise<CalibrationSet[]> {\n    const params = agentId ? `?agentId=${agentId}` : '';\n    return apiRequestWithData<CalibrationSet[]>(\n      `/human-review/calibration-sets${params}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Create a calibration set\n   *\n   * @example\n   * ```typescript\n   * const set = await humanReview.createCalibrationSet({\n   *   name: 'Quality Calibration Q1',\n   *   agentId: 'agent_123',\n   *   targetAgreement: 0.85,\n   *   minSamples: 50,\n   * });\n   * ```\n   */\n  async createCalibrationSet(options: CreateCalibrationSetOptions): Promise<CalibrationSet> {\n    return apiRequestWithData<CalibrationSet>('/human-review/calibration-sets', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get a calibration set by ID\n   *\n   * @example\n   * ```typescript\n   * const set = await humanReview.getCalibrationSet('set_123');\n   * ```\n   */\n  async getCalibrationSet(setId: string): Promise<CalibrationSet> {\n    return apiRequestWithData<CalibrationSet>(\n      `/human-review/calibration-sets/${setId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  // ---------------------------------------------------------------------------\n  // REVIEWER CALIBRATION\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get certified reviewers for a calibration set\n   *\n   * @example\n   * ```typescript\n   * const reviewers = await humanReview.getCertifiedReviewers('set_123');\n   * ```\n   */\n  async getCertifiedReviewers(calibrationSetId: string): Promise<ReviewerCalibration[]> {\n    return apiRequestWithData<ReviewerCalibration[]>(\n      `/human-review/reviewers?calibrationSetId=${calibrationSetId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get reviewer calibration status\n   *\n   * @example\n   * ```typescript\n   * const calibrations = await humanReview.getReviewerCalibrations('user_123');\n   * ```\n   */\n  async getReviewerCalibrations(userId: string): Promise<ReviewerCalibration[]> {\n    return apiRequestWithData<ReviewerCalibration[]>(\n      `/human-review/calibration/${userId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n};\n"]}