@thinkhive/sdk 3.1.1 → 4.0.0

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: 'none' });
+    },
+    /**
+     * 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: 'none',
+        });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+    /**
+     * Get available review types
+     *
+     * @example
+     * ```typescript
+     * const types = await humanReview.getReviewTypes();
+     * ```
+     */
+    async getReviewTypes() {
+        return (0, client_1.apiRequestWithData)('/human-review/review-types', { apiVersion: 'none' });
+    },
+    // ---------------------------------------------------------------------------
+    // 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: 'none' });
+    },
+    /**
+     * 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: 'none',
+        });
+    },
+    /**
+     * 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: 'none' });
+    },
+    // ---------------------------------------------------------------------------
+    // 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: 'none' });
+    },
+    /**
+     * 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: 'none' });
+    },
+};
+//# 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: 'none' }\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: 'none',\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: 'none' }\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: 'none' }\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: 'none' }\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: 'none' }\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: 'none' }\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: 'none' }\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: 'none' }\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: 'none' });\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: 'none' }\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: 'none',\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: 'none' }\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: 'none' }\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: 'none' }\n    );\n  },\n};\n"]}

package/dist/api/nondeterminism.d.ts

@@ -0,0 +1,300 @@
+/**
+ * ThinkHive SDK v3.0 - Non-Determinism API
+ *
+ * API for pass@k / pass^k analysis to measure LLM evaluation reliability
+ */
+export type NondeterminismRunType = 'pass_at_k' | 'pass_to_k' | 'variance' | 'reliability';
+export type NondeterminismRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface NondeterminismRun {
+    id: string;
+    companyId: string;
+    agentId: string;
+    runType: NondeterminismRunType;
+    kValue: number;
+    status: NondeterminismRunStatus;
+    traceCount: number;
+    criterionId?: string;
+    criteriaIds: string[];
+    temperature?: string;
+    model?: string;
+    progressPercent: number;
+    passAtKRate?: string;
+    passToKRate?: string;
+    avgVariance?: string;
+    reliabilityScore?: string;
+    startedAt?: string;
+    completedAt?: string;
+    createdBy?: string;
+    createdAt: string;
+}
+export interface NondeterminismSample {
+    id: string;
+    runId: string;
+    traceId: string;
+    criterionId: string;
+    sampleIndex: number;
+    score: string;
+    passed: boolean;
+    reasoning?: string;
+    confidence?: string;
+    tokensUsed?: number;
+    costUsd?: string;
+    model?: string;
+    temperature?: string;
+    latencyMs?: number;
+    error?: string;
+    createdAt: string;
+}
+export interface CreateRunOptions {
+    agentId: string;
+    criterionId?: string;
+    criteriaIds?: string[];
+    kValue: number;
+    traceIds: string[];
+    runType?: NondeterminismRunType;
+    temperature?: number;
+    model?: string;
+}
+export interface RecordSampleOptions {
+    runId: string;
+    traceId: string;
+    criterionId: string;
+    sampleIndex: number;
+    score: number;
+    passed: boolean;
+    reasoning?: string;
+    confidence?: number;
+    tokensUsed?: number;
+    costUsd?: number;
+    model?: string;
+    temperature?: number;
+    latencyMs?: number;
+    error?: string;
+}
+export interface TraceAnalysis {
+    traceId: string;
+    samples: NondeterminismSample[];
+    passCount: number;
+    totalCount: number;
+    passRate: number;
+    scoreVariance: number;
+    meanScore: number;
+    isConsistent: boolean;
+}
+export interface CriterionAnalysis {
+    criterionId: string;
+    traceAnalyses: TraceAnalysis[];
+    passAtKRate: number;
+    passToKRate: number;
+    reliabilityScore: number;
+    isReliable: boolean;
+    recommendation: string;
+}
+export interface RunSummary {
+    run: NondeterminismRun;
+    traceAnalyses: TraceAnalysis[];
+    criterionAnalyses: CriterionAnalysis[];
+}
+export interface ListRunsOptions {
+    agentId?: string;
+    status?: NondeterminismRunStatus;
+    limit?: number;
+    offset?: number;
+}
+export interface PassAtKInfo {
+    concepts: {
+        passAtK: {
+            name: string;
+            description: string;
+            formula: string;
+            useCase: string;
+        };
+        passToK: {
+            name: string;
+            description: string;
+            formula: string;
+            useCase: string;
+        };
+        variance: {
+            name: string;
+            description: string;
+            useCase: string;
+        };
+        reliability: {
+            name: string;
+            description: string;
+            useCase: string;
+        };
+    };
+    recommendations: Record<string, string>;
+    defaults: {
+        kValue: number;
+        reliabilityThreshold: number;
+        varianceThreshold: number;
+    };
+}
+/**
+ * Non-Determinism API client for pass@k analysis and reliability measurement
+ */
+export declare const nondeterminism: {
+    /**
+     * Create a new non-determinism analysis run
+     *
+     * @example
+     * ```typescript
+     * const run = await nondeterminism.createRun({
+     *   agentId: 'agent_123',
+     *   criterionId: 'criterion_456',
+     *   kValue: 5,
+     *   traceIds: ['trace_1', 'trace_2', 'trace_3'],
+     *   runType: 'pass_at_k',
+     * });
+     * ```
+     */
+    createRun(options: CreateRunOptions): Promise<NondeterminismRun>;
+    /**
+     * Get non-determinism runs
+     *
+     * @example
+     * ```typescript
+     * const runs = await nondeterminism.getRuns({ agentId: 'agent_123' });
+     * ```
+     */
+    getRuns(options?: ListRunsOptions): Promise<NondeterminismRun[]>;
+    /**
+     * Get a specific run
+     *
+     * @example
+     * ```typescript
+     * const run = await nondeterminism.getRun('run_123');
+     * ```
+     */
+    getRun(runId: string): Promise<NondeterminismRun>;
+    /**
+     * Start a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.startRun('run_123');
+     * ```
+     */
+    startRun(runId: string): Promise<void>;
+    /**
+     * Complete a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.completeRun('run_123');
+     * ```
+     */
+    completeRun(runId: string): Promise<void>;
+    /**
+     * Record a sample result
+     *
+     * @example
+     * ```typescript
+     * const sample = await nondeterminism.recordSample({
+     *   runId: 'run_123',
+     *   traceId: 'trace_456',
+     *   criterionId: 'criterion_789',
+     *   sampleIndex: 0,
+     *   score: 85,
+     *   passed: true,
+     *   reasoning: 'Response meets quality criteria',
+     * });
+     * ```
+     */
+    recordSample(options: RecordSampleOptions): Promise<NondeterminismSample>;
+    /**
+     * Get samples for a run
+     *
+     * @example
+     * ```typescript
+     * const samples = await nondeterminism.getSamples('run_123');
+     * ```
+     */
+    getSamples(runId: string): Promise<NondeterminismSample[]>;
+    /**
+     * Get run summary with analysis
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.getRunSummary('run_123');
+     * console.log(`Pass@k rate: ${summary.criterionAnalyses[0].passAtKRate}`);
+     * ```
+     */
+    getRunSummary(runId: string): Promise<RunSummary>;
+    /**
+     * Trigger analysis of a completed run
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.analyzeRun('run_123');
+     * ```
+     */
+    analyzeRun(runId: string): Promise<RunSummary>;
+    /**
+     * Get information about pass@k analysis
+     *
+     * @example
+     * ```typescript
+     * const info = await nondeterminism.getInfo();
+     * console.log(info.concepts.passAtK.description);
+     * ```
+     */
+    getInfo(): Promise<PassAtKInfo>;
+};
+/**
+ * Calculate pass@k probability from pass rate
+ *
+ * @param passRate - Single-run pass rate (0-1)
+ * @param k - Number of runs
+ * @returns Probability that at least 1 of k runs passes
+ *
+ * @example
+ * ```typescript
+ * const passAtK = calculatePassAtK(0.7, 3); // ~0.973
+ * ```
+ */
+export declare function calculatePassAtK(passRate: number, k: number): number;
+/**
+ * Calculate pass^k probability from pass rate
+ *
+ * @param passRate - Single-run pass rate (0-1)
+ * @param k - Number of runs
+ * @returns Probability that all k runs pass
+ *
+ * @example
+ * ```typescript
+ * const passToK = calculatePassToK(0.7, 3); // ~0.343
+ * ```
+ */
+export declare function calculatePassToK(passRate: number, k: number): number;
+/**
+ * Calculate required pass rate to achieve target pass@k
+ *
+ * @param targetPassAtK - Desired pass@k probability
+ * @param k - Number of runs
+ * @returns Required single-run pass rate
+ *
+ * @example
+ * ```typescript
+ * const requiredRate = requiredPassRateForPassAtK(0.95, 3); // ~0.632
+ * ```
+ */
+export declare function requiredPassRateForPassAtK(targetPassAtK: number, k: number): number;
+/**
+ * Determine if evaluation is reliable based on analysis
+ *
+ * @param analysis - Criterion analysis result
+ * @param reliabilityThreshold - Minimum reliability score (default 0.8)
+ * @returns Whether the evaluation is considered reliable
+ */
+export declare function isReliableEvaluation(analysis: CriterionAnalysis, reliabilityThreshold?: number): boolean;
+/**
+ * Get recommendation based on reliability analysis
+ *
+ * @param analysis - Criterion analysis result
+ * @returns Actionable recommendation string
+ */
+export declare function getReliabilityRecommendation(analysis: CriterionAnalysis): string;