@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/eval-health.d.ts

@@ -0,0 +1,250 @@
+/**
+ * ThinkHive SDK v3.0 - Evaluation Health API
+ *
+ * API for eval saturation monitoring, regression detection, and health reports
+ */
+export type SaturationType = 'ceiling' | 'floor' | 'healthy';
+export type HealthStatus = 'healthy' | 'warning' | 'critical';
+export type RegressionSeverity = 'minor' | 'moderate' | 'severe';
+export interface EvalHealthSnapshot {
+    id: string;
+    companyId: string;
+    agentId: string;
+    criterionId?: string;
+    snapshotDate: string;
+    passRate?: string;
+    evalCount?: number;
+    meanScore?: string;
+    saturationType?: SaturationType;
+    daysAtSaturation?: number;
+    trendDirection?: string;
+    trendStrength?: string;
+    healthStatus?: HealthStatus;
+    healthScore?: string;
+    createdAt: string;
+}
+export interface EvalRegression {
+    id: string;
+    companyId: string;
+    agentId: string;
+    criterionId?: string;
+    severity: RegressionSeverity;
+    baselinePassRate: string;
+    currentPassRate: string;
+    delta: string;
+    deltaPercent?: string;
+    baselinePeriodStart: string;
+    baselinePeriodEnd: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    baselineEvalCount?: number;
+    currentEvalCount?: number;
+    suspectedCauses?: unknown[];
+    isSignificant?: boolean;
+    isResolved: boolean;
+    isAcknowledged: boolean;
+    resolvedAt?: string;
+    resolvedBy?: string;
+    resolutionType?: string;
+    resolutionNotes?: string;
+    acknowledgedAt?: string;
+    acknowledgedBy?: string;
+    detectedAt: string;
+    createdAt: string;
+}
+export interface HealthReport {
+    agentId: string;
+    generatedAt: string;
+    overallHealth: HealthStatus;
+    overallScore: number;
+    passRate: number;
+    evalCount: number;
+    saturationStatus: {
+        type: SaturationType;
+        daysAtSaturation: number;
+        recommendation: string;
+    };
+    regressionCount: number;
+    activeRegressions: EvalRegression[];
+    trend: {
+        direction: 'improving' | 'stable' | 'declining';
+        strength: number;
+        description: string;
+    };
+    recommendations: string[];
+}
+export interface CreateSnapshotOptions {
+    agentId: string;
+    criterionId?: string;
+    snapshotDate: string;
+    passRate?: string;
+    evalCount?: number;
+    meanScore?: string;
+    saturationType?: SaturationType;
+    daysAtSaturation?: number;
+    trendDirection?: string;
+    trendStrength?: string;
+    healthStatus?: HealthStatus;
+    healthScore?: string;
+}
+export interface CreateRegressionOptions {
+    agentId: string;
+    criterionId?: string;
+    severity: RegressionSeverity;
+    baselinePassRate: string;
+    currentPassRate: string;
+    delta: string;
+    deltaPercent?: string;
+    baselinePeriodStart: string;
+    baselinePeriodEnd: string;
+    currentPeriodStart: string;
+    currentPeriodEnd: string;
+    baselineEvalCount?: number;
+    currentEvalCount?: number;
+    suspectedCauses?: unknown[];
+    isSignificant?: boolean;
+    detectedAt?: string;
+}
+export interface ResolveRegressionOptions {
+    resolutionType: string;
+    notes?: string;
+}
+export interface GetSnapshotsOptions {
+    agentId: string;
+    criterionId?: string;
+    startDate?: string;
+    endDate?: string;
+}
+/**
+ * Evaluation Health API client for monitoring eval quality and detecting regressions
+ */
+export declare const evalHealth: {
+    /**
+     * Get comprehensive health report for an agent
+     *
+     * @example
+     * ```typescript
+     * const report = await evalHealth.getReport('agent_123');
+     * console.log(`Overall health: ${report.overallHealth}`);
+     * console.log(`Active regressions: ${report.regressionCount}`);
+     * ```
+     */
+    getReport(agentId: string): Promise<HealthReport>;
+    /**
+     * Get historical health snapshots
+     *
+     * @example
+     * ```typescript
+     * const snapshots = await evalHealth.getSnapshots({
+     *   agentId: 'agent_123',
+     *   startDate: '2024-01-01T00:00:00Z',
+     *   endDate: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    getSnapshots(options: GetSnapshotsOptions): Promise<EvalHealthSnapshot[]>;
+    /**
+     * Get latest health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.getLatestSnapshot('agent_123');
+     * ```
+     */
+    getLatestSnapshot(agentId: string, criterionId?: string): Promise<EvalHealthSnapshot | null>;
+    /**
+     * Record a health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.recordSnapshot({
+     *   agentId: 'agent_123',
+     *   snapshotDate: new Date().toISOString(),
+     *   passRate: '0.85',
+     *   evalCount: 150,
+     *   healthStatus: 'healthy',
+     * });
+     * ```
+     */
+    recordSnapshot(options: CreateSnapshotOptions): Promise<EvalHealthSnapshot>;
+    /**
+     * Get unresolved regressions for an agent
+     *
+     * @example
+     * ```typescript
+     * const regressions = await evalHealth.getRegressions('agent_123');
+     * for (const regression of regressions) {
+     *   console.log(`${regression.severity}: ${regression.delta}% drop`);
+     * }
+     * ```
+     */
+    getRegressions(agentId: string): Promise<EvalRegression[]>;
+    /**
+     * Record a new regression
+     *
+     * @example
+     * ```typescript
+     * const regression = await evalHealth.recordRegression({
+     *   agentId: 'agent_123',
+     *   severity: 'moderate',
+     *   baselinePassRate: '0.92',
+     *   currentPassRate: '0.78',
+     *   delta: '-0.14',
+     *   baselinePeriodStart: '2024-01-01T00:00:00Z',
+     *   baselinePeriodEnd: '2024-01-15T23:59:59Z',
+     *   currentPeriodStart: '2024-01-16T00:00:00Z',
+     *   currentPeriodEnd: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    recordRegression(options: CreateRegressionOptions): Promise<EvalRegression>;
+    /**
+     * Resolve a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.resolveRegression('regression_123', {
+     *   resolutionType: 'fixed',
+     *   notes: 'Updated prompt template to address quality issues',
+     * });
+     * ```
+     */
+    resolveRegression(regressionId: string, options: ResolveRegressionOptions): Promise<void>;
+    /**
+     * Acknowledge a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.acknowledgeRegression('regression_123');
+     * ```
+     */
+    acknowledgeRegression(regressionId: string): Promise<void>;
+};
+/**
+ * Check if health status indicates an issue
+ *
+ * @param status - Health status to check
+ * @returns Whether the status indicates a problem
+ */
+export declare function hasHealthIssue(status: HealthStatus): boolean;
+/**
+ * Get severity level as numeric value for sorting
+ *
+ * @param severity - Regression severity
+ * @returns Numeric severity (1-3, higher is worse)
+ */
+export declare function getSeverityLevel(severity: RegressionSeverity): number;
+/**
+ * Check if evaluation is saturated
+ *
+ * @param snapshot - Health snapshot to check
+ * @returns Whether evaluation is at ceiling or floor
+ */
+export declare function isSaturated(snapshot: EvalHealthSnapshot): boolean;
+/**
+ * Get recommendation for saturation type
+ *
+ * @param saturationType - Type of saturation
+ * @returns Recommendation string
+ */
+export declare function getSaturationRecommendation(saturationType: SaturationType): string;

package/dist/api/eval-health.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Evaluation Health API
+ *
+ * API for eval saturation monitoring, regression detection, and health reports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalHealth = void 0;
+exports.hasHealthIssue = hasHealthIssue;
+exports.getSeverityLevel = getSeverityLevel;
+exports.isSaturated = isSaturated;
+exports.getSaturationRecommendation = getSaturationRecommendation;
+const client_1 = require("../core/client");
+// ============================================================================
+// EVAL HEALTH API CLIENT
+// ============================================================================
+/**
+ * Evaluation Health API client for monitoring eval quality and detecting regressions
+ */
+exports.evalHealth = {
+    /**
+     * Get comprehensive health report for an agent
+     *
+     * @example
+     * ```typescript
+     * const report = await evalHealth.getReport('agent_123');
+     * console.log(`Overall health: ${report.overallHealth}`);
+     * console.log(`Active regressions: ${report.regressionCount}`);
+     * ```
+     */
+    async getReport(agentId) {
+        return (0, client_1.apiRequestWithData)(`/eval-health/report?agentId=${agentId}`, { apiVersion: 'v1' });
+    },
+    // ---------------------------------------------------------------------------
+    // SNAPSHOTS
+    // ---------------------------------------------------------------------------
+    /**
+     * Get historical health snapshots
+     *
+     * @example
+     * ```typescript
+     * const snapshots = await evalHealth.getSnapshots({
+     *   agentId: 'agent_123',
+     *   startDate: '2024-01-01T00:00:00Z',
+     *   endDate: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    async getSnapshots(options) {
+        const params = new URLSearchParams();
+        params.set('agentId', options.agentId);
+        if (options.criterionId)
+            params.set('criterionId', options.criterionId);
+        if (options.startDate)
+            params.set('startDate', options.startDate);
+        if (options.endDate)
+            params.set('endDate', options.endDate);
+        return (0, client_1.apiRequestWithData)(`/eval-health/snapshots?${params.toString()}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get latest health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.getLatestSnapshot('agent_123');
+     * ```
+     */
+    async getLatestSnapshot(agentId, criterionId) {
+        const params = new URLSearchParams();
+        params.set('agentId', agentId);
+        if (criterionId)
+            params.set('criterionId', criterionId);
+        return (0, client_1.apiRequestWithData)(`/eval-health/snapshots/latest?${params.toString()}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Record a health snapshot
+     *
+     * @example
+     * ```typescript
+     * const snapshot = await evalHealth.recordSnapshot({
+     *   agentId: 'agent_123',
+     *   snapshotDate: new Date().toISOString(),
+     *   passRate: '0.85',
+     *   evalCount: 150,
+     *   healthStatus: 'healthy',
+     * });
+     * ```
+     */
+    async recordSnapshot(options) {
+        return (0, client_1.apiRequestWithData)('/eval-health/snapshots', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    // ---------------------------------------------------------------------------
+    // REGRESSIONS
+    // ---------------------------------------------------------------------------
+    /**
+     * Get unresolved regressions for an agent
+     *
+     * @example
+     * ```typescript
+     * const regressions = await evalHealth.getRegressions('agent_123');
+     * for (const regression of regressions) {
+     *   console.log(`${regression.severity}: ${regression.delta}% drop`);
+     * }
+     * ```
+     */
+    async getRegressions(agentId) {
+        return (0, client_1.apiRequestWithData)(`/eval-health/regressions?agentId=${agentId}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Record a new regression
+     *
+     * @example
+     * ```typescript
+     * const regression = await evalHealth.recordRegression({
+     *   agentId: 'agent_123',
+     *   severity: 'moderate',
+     *   baselinePassRate: '0.92',
+     *   currentPassRate: '0.78',
+     *   delta: '-0.14',
+     *   baselinePeriodStart: '2024-01-01T00:00:00Z',
+     *   baselinePeriodEnd: '2024-01-15T23:59:59Z',
+     *   currentPeriodStart: '2024-01-16T00:00:00Z',
+     *   currentPeriodEnd: '2024-01-31T23:59:59Z',
+     * });
+     * ```
+     */
+    async recordRegression(options) {
+        return (0, client_1.apiRequestWithData)('/eval-health/regressions', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Resolve a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.resolveRegression('regression_123', {
+     *   resolutionType: 'fixed',
+     *   notes: 'Updated prompt template to address quality issues',
+     * });
+     * ```
+     */
+    async resolveRegression(regressionId, options) {
+        await (0, client_1.apiRequest)(`/eval-health/regressions/${regressionId}/resolve`, {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Acknowledge a regression
+     *
+     * @example
+     * ```typescript
+     * await evalHealth.acknowledgeRegression('regression_123');
+     * ```
+     */
+    async acknowledgeRegression(regressionId) {
+        await (0, client_1.apiRequest)(`/eval-health/regressions/${regressionId}/acknowledge`, {
+            method: 'POST',
+            apiVersion: 'v1',
+        });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if health status indicates an issue
+ *
+ * @param status - Health status to check
+ * @returns Whether the status indicates a problem
+ */
+function hasHealthIssue(status) {
+    return status === 'warning' || status === 'critical';
+}
+/**
+ * Get severity level as numeric value for sorting
+ *
+ * @param severity - Regression severity
+ * @returns Numeric severity (1-3, higher is worse)
+ */
+function getSeverityLevel(severity) {
+    switch (severity) {
+        case 'minor': return 1;
+        case 'moderate': return 2;
+        case 'severe': return 3;
+        default: return 0;
+    }
+}
+/**
+ * Check if evaluation is saturated
+ *
+ * @param snapshot - Health snapshot to check
+ * @returns Whether evaluation is at ceiling or floor
+ */
+function isSaturated(snapshot) {
+    return snapshot.saturationType === 'ceiling' || snapshot.saturationType === 'floor';
+}
+/**
+ * Get recommendation for saturation type
+ *
+ * @param saturationType - Type of saturation
+ * @returns Recommendation string
+ */
+function getSaturationRecommendation(saturationType) {
+    switch (saturationType) {
+        case 'ceiling':
+            return 'Evaluation criteria may be too lenient. Consider adding stricter checks or more challenging test cases.';
+        case 'floor':
+            return 'Evaluation criteria may be too strict. Consider relaxing thresholds or reviewing criteria for accuracy.';
+        case 'healthy':
+            return 'Evaluation is operating within healthy parameters.';
+        default:
+            return 'Unable to determine saturation status.';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eval-health.js","sourceRoot":"","sources":["../../src/api/eval-health.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Evaluation Health API\n *\n * API for eval saturation monitoring, regression detection, and health reports\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type SaturationType = 'ceiling' | 'floor' | 'healthy';\nexport type HealthStatus = 'healthy' | 'warning' | 'critical';\nexport type RegressionSeverity = 'minor' | 'moderate' | 'severe';\n\nexport interface EvalHealthSnapshot {\n  id: string;\n  companyId: string;\n  agentId: string;\n  criterionId?: string;\n  snapshotDate: string;\n  passRate?: string;\n  evalCount?: number;\n  meanScore?: string;\n  saturationType?: SaturationType;\n  daysAtSaturation?: number;\n  trendDirection?: string;\n  trendStrength?: string;\n  healthStatus?: HealthStatus;\n  healthScore?: string;\n  createdAt: string;\n}\n\nexport interface EvalRegression {\n  id: string;\n  companyId: string;\n  agentId: string;\n  criterionId?: string;\n  severity: RegressionSeverity;\n  baselinePassRate: string;\n  currentPassRate: string;\n  delta: string;\n  deltaPercent?: string;\n  baselinePeriodStart: string;\n  baselinePeriodEnd: string;\n  currentPeriodStart: string;\n  currentPeriodEnd: string;\n  baselineEvalCount?: number;\n  currentEvalCount?: number;\n  suspectedCauses?: unknown[];\n  isSignificant?: boolean;\n  isResolved: boolean;\n  isAcknowledged: boolean;\n  resolvedAt?: string;\n  resolvedBy?: string;\n  resolutionType?: string;\n  resolutionNotes?: string;\n  acknowledgedAt?: string;\n  acknowledgedBy?: string;\n  detectedAt: string;\n  createdAt: string;\n}\n\nexport interface HealthReport {\n  agentId: string;\n  generatedAt: string;\n  overallHealth: HealthStatus;\n  overallScore: number;\n  passRate: number;\n  evalCount: number;\n  saturationStatus: {\n    type: SaturationType;\n    daysAtSaturation: number;\n    recommendation: string;\n  };\n  regressionCount: number;\n  activeRegressions: EvalRegression[];\n  trend: {\n    direction: 'improving' | 'stable' | 'declining';\n    strength: number;\n    description: string;\n  };\n  recommendations: string[];\n}\n\nexport interface CreateSnapshotOptions {\n  agentId: string;\n  criterionId?: string;\n  snapshotDate: string;\n  passRate?: string;\n  evalCount?: number;\n  meanScore?: string;\n  saturationType?: SaturationType;\n  daysAtSaturation?: number;\n  trendDirection?: string;\n  trendStrength?: string;\n  healthStatus?: HealthStatus;\n  healthScore?: string;\n}\n\nexport interface CreateRegressionOptions {\n  agentId: string;\n  criterionId?: string;\n  severity: RegressionSeverity;\n  baselinePassRate: string;\n  currentPassRate: string;\n  delta: string;\n  deltaPercent?: string;\n  baselinePeriodStart: string;\n  baselinePeriodEnd: string;\n  currentPeriodStart: string;\n  currentPeriodEnd: string;\n  baselineEvalCount?: number;\n  currentEvalCount?: number;\n  suspectedCauses?: unknown[];\n  isSignificant?: boolean;\n  detectedAt?: string;\n}\n\nexport interface ResolveRegressionOptions {\n  resolutionType: string;\n  notes?: string;\n}\n\nexport interface GetSnapshotsOptions {\n  agentId: string;\n  criterionId?: string;\n  startDate?: string;\n  endDate?: string;\n}\n\n// ============================================================================\n// EVAL HEALTH API CLIENT\n// ============================================================================\n\n/**\n * Evaluation Health API client for monitoring eval quality and detecting regressions\n */\nexport const evalHealth = {\n  /**\n   * Get comprehensive health report for an agent\n   *\n   * @example\n   * ```typescript\n   * const report = await evalHealth.getReport('agent_123');\n   * console.log(`Overall health: ${report.overallHealth}`);\n   * console.log(`Active regressions: ${report.regressionCount}`);\n   * ```\n   */\n  async getReport(agentId: string): Promise<HealthReport> {\n    return apiRequestWithData<HealthReport>(\n      `/eval-health/report?agentId=${agentId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  // ---------------------------------------------------------------------------\n  // SNAPSHOTS\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get historical health snapshots\n   *\n   * @example\n   * ```typescript\n   * const snapshots = await evalHealth.getSnapshots({\n   *   agentId: 'agent_123',\n   *   startDate: '2024-01-01T00:00:00Z',\n   *   endDate: '2024-01-31T23:59:59Z',\n   * });\n   * ```\n   */\n  async getSnapshots(options: GetSnapshotsOptions): Promise<EvalHealthSnapshot[]> {\n    const params = new URLSearchParams();\n    params.set('agentId', options.agentId);\n    if (options.criterionId) params.set('criterionId', options.criterionId);\n    if (options.startDate) params.set('startDate', options.startDate);\n    if (options.endDate) params.set('endDate', options.endDate);\n\n    return apiRequestWithData<EvalHealthSnapshot[]>(\n      `/eval-health/snapshots?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get latest health snapshot\n   *\n   * @example\n   * ```typescript\n   * const snapshot = await evalHealth.getLatestSnapshot('agent_123');\n   * ```\n   */\n  async getLatestSnapshot(agentId: string, criterionId?: string): Promise<EvalHealthSnapshot | null> {\n    const params = new URLSearchParams();\n    params.set('agentId', agentId);\n    if (criterionId) params.set('criterionId', criterionId);\n\n    return apiRequestWithData<EvalHealthSnapshot | null>(\n      `/eval-health/snapshots/latest?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Record a health snapshot\n   *\n   * @example\n   * ```typescript\n   * const snapshot = await evalHealth.recordSnapshot({\n   *   agentId: 'agent_123',\n   *   snapshotDate: new Date().toISOString(),\n   *   passRate: '0.85',\n   *   evalCount: 150,\n   *   healthStatus: 'healthy',\n   * });\n   * ```\n   */\n  async recordSnapshot(options: CreateSnapshotOptions): Promise<EvalHealthSnapshot> {\n    return apiRequestWithData<EvalHealthSnapshot>('/eval-health/snapshots', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  // ---------------------------------------------------------------------------\n  // REGRESSIONS\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Get unresolved regressions for an agent\n   *\n   * @example\n   * ```typescript\n   * const regressions = await evalHealth.getRegressions('agent_123');\n   * for (const regression of regressions) {\n   *   console.log(`${regression.severity}: ${regression.delta}% drop`);\n   * }\n   * ```\n   */\n  async getRegressions(agentId: string): Promise<EvalRegression[]> {\n    return apiRequestWithData<EvalRegression[]>(\n      `/eval-health/regressions?agentId=${agentId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Record a new regression\n   *\n   * @example\n   * ```typescript\n   * const regression = await evalHealth.recordRegression({\n   *   agentId: 'agent_123',\n   *   severity: 'moderate',\n   *   baselinePassRate: '0.92',\n   *   currentPassRate: '0.78',\n   *   delta: '-0.14',\n   *   baselinePeriodStart: '2024-01-01T00:00:00Z',\n   *   baselinePeriodEnd: '2024-01-15T23:59:59Z',\n   *   currentPeriodStart: '2024-01-16T00:00:00Z',\n   *   currentPeriodEnd: '2024-01-31T23:59:59Z',\n   * });\n   * ```\n   */\n  async recordRegression(options: CreateRegressionOptions): Promise<EvalRegression> {\n    return apiRequestWithData<EvalRegression>('/eval-health/regressions', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Resolve a regression\n   *\n   * @example\n   * ```typescript\n   * await evalHealth.resolveRegression('regression_123', {\n   *   resolutionType: 'fixed',\n   *   notes: 'Updated prompt template to address quality issues',\n   * });\n   * ```\n   */\n  async resolveRegression(regressionId: string, options: ResolveRegressionOptions): Promise<void> {\n    await apiRequest(`/eval-health/regressions/${regressionId}/resolve`, {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Acknowledge a regression\n   *\n   * @example\n   * ```typescript\n   * await evalHealth.acknowledgeRegression('regression_123');\n   * ```\n   */\n  async acknowledgeRegression(regressionId: string): Promise<void> {\n    await apiRequest(`/eval-health/regressions/${regressionId}/acknowledge`, {\n      method: 'POST',\n      apiVersion: 'v1',\n    });\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if health status indicates an issue\n *\n * @param status - Health status to check\n * @returns Whether the status indicates a problem\n */\nexport function hasHealthIssue(status: HealthStatus): boolean {\n  return status === 'warning' || status === 'critical';\n}\n\n/**\n * Get severity level as numeric value for sorting\n *\n * @param severity - Regression severity\n * @returns Numeric severity (1-3, higher is worse)\n */\nexport function getSeverityLevel(severity: RegressionSeverity): number {\n  switch (severity) {\n    case 'minor': return 1;\n    case 'moderate': return 2;\n    case 'severe': return 3;\n    default: return 0;\n  }\n}\n\n/**\n * Check if evaluation is saturated\n *\n * @param snapshot - Health snapshot to check\n * @returns Whether evaluation is at ceiling or floor\n */\nexport function isSaturated(snapshot: EvalHealthSnapshot): boolean {\n  return snapshot.saturationType === 'ceiling' || snapshot.saturationType === 'floor';\n}\n\n/**\n * Get recommendation for saturation type\n *\n * @param saturationType - Type of saturation\n * @returns Recommendation string\n */\nexport function getSaturationRecommendation(saturationType: SaturationType): string {\n  switch (saturationType) {\n    case 'ceiling':\n      return 'Evaluation criteria may be too lenient. Consider adding stricter checks or more challenging test cases.';\n    case 'floor':\n      return 'Evaluation criteria may be too strict. Consider relaxing thresholds or reviewing criteria for accuracy.';\n    case 'healthy':\n      return 'Evaluation is operating within healthy parameters.';\n    default:\n      return 'Unable to determine saturation status.';\n  }\n}\n"]}