@thinkhive/sdk 3.1.0 → 3.3.0

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;

package/dist/api/nondeterminism.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Non-Determinism API
+ *
+ * API for pass@k / pass^k analysis to measure LLM evaluation reliability
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nondeterminism = void 0;
+exports.calculatePassAtK = calculatePassAtK;
+exports.calculatePassToK = calculatePassToK;
+exports.requiredPassRateForPassAtK = requiredPassRateForPassAtK;
+exports.isReliableEvaluation = isReliableEvaluation;
+exports.getReliabilityRecommendation = getReliabilityRecommendation;
+const client_1 = require("../core/client");
+// ============================================================================
+// NON-DETERMINISM API CLIENT
+// ============================================================================
+/**
+ * Non-Determinism API client for pass@k analysis and reliability measurement
+ */
+exports.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',
+     * });
+     * ```
+     */
+    async createRun(options) {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/runs', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get non-determinism runs
+     *
+     * @example
+     * ```typescript
+     * const runs = await nondeterminism.getRuns({ agentId: 'agent_123' });
+     * ```
+     */
+    async getRuns(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agentId)
+            params.set('agentId', options.agentId);
+        if (options.status)
+            params.set('status', options.status);
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.offset)
+            params.set('offset', String(options.offset));
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs?${params.toString()}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get a specific run
+     *
+     * @example
+     * ```typescript
+     * const run = await nondeterminism.getRun('run_123');
+     * ```
+     */
+    async getRun(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}`, { apiVersion: 'v1' });
+    },
+    /**
+     * Start a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.startRun('run_123');
+     * ```
+     */
+    async startRun(runId) {
+        await (0, client_1.apiRequest)(`/nondeterminism/runs/${runId}/start`, {
+            method: 'POST',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Complete a run
+     *
+     * @example
+     * ```typescript
+     * await nondeterminism.completeRun('run_123');
+     * ```
+     */
+    async completeRun(runId) {
+        await (0, client_1.apiRequest)(`/nondeterminism/runs/${runId}/complete`, {
+            method: 'POST',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * 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',
+     * });
+     * ```
+     */
+    async recordSample(options) {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/samples', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get samples for a run
+     *
+     * @example
+     * ```typescript
+     * const samples = await nondeterminism.getSamples('run_123');
+     * ```
+     */
+    async getSamples(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/samples`, { apiVersion: 'v1' });
+    },
+    /**
+     * Get run summary with analysis
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.getRunSummary('run_123');
+     * console.log(`Pass@k rate: ${summary.criterionAnalyses[0].passAtKRate}`);
+     * ```
+     */
+    async getRunSummary(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/summary`, { apiVersion: 'v1' });
+    },
+    /**
+     * Trigger analysis of a completed run
+     *
+     * @example
+     * ```typescript
+     * const summary = await nondeterminism.analyzeRun('run_123');
+     * ```
+     */
+    async analyzeRun(runId) {
+        return (0, client_1.apiRequestWithData)(`/nondeterminism/runs/${runId}/analyze`, { method: 'POST', apiVersion: 'v1' });
+    },
+    /**
+     * Get information about pass@k analysis
+     *
+     * @example
+     * ```typescript
+     * const info = await nondeterminism.getInfo();
+     * console.log(info.concepts.passAtK.description);
+     * ```
+     */
+    async getInfo() {
+        return (0, client_1.apiRequestWithData)('/nondeterminism/info', { apiVersion: 'v1' });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * 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
+ * ```
+ */
+function calculatePassAtK(passRate, k) {
+    return 1 - Math.pow(1 - passRate, k);
+}
+/**
+ * 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
+ * ```
+ */
+function calculatePassToK(passRate, k) {
+    return Math.pow(passRate, k);
+}
+/**
+ * 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
+ * ```
+ */
+function requiredPassRateForPassAtK(targetPassAtK, k) {
+    return 1 - Math.pow(1 - targetPassAtK, 1 / k);
+}
+/**
+ * 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
+ */
+function isReliableEvaluation(analysis, reliabilityThreshold = 0.8) {
+    return analysis.reliabilityScore >= reliabilityThreshold;
+}
+/**
+ * Get recommendation based on reliability analysis
+ *
+ * @param analysis - Criterion analysis result
+ * @returns Actionable recommendation string
+ */
+function getReliabilityRecommendation(analysis) {
+    if (analysis.reliabilityScore >= 0.9) {
+        return 'Evaluation is highly reliable. No changes needed.';
+    }
+    else if (analysis.reliabilityScore >= 0.8) {
+        return 'Evaluation is reliable. Consider minor criteria refinements.';
+    }
+    else if (analysis.reliabilityScore >= 0.6) {
+        return 'Evaluation has moderate reliability. Add more specific criteria or examples.';
+    }
+    else {
+        return 'Evaluation is unreliable. Consider using deterministic checks or restructuring criteria.';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nondeterminism.js","sourceRoot":"","sources":["../../src/api/nondeterminism.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Non-Determinism API\n *\n * API for pass@k / pass^k analysis to measure LLM evaluation reliability\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type NondeterminismRunType = 'pass_at_k' | 'pass_to_k' | 'variance' | 'reliability';\nexport type NondeterminismRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';\n\nexport interface NondeterminismRun {\n  id: string;\n  companyId: string;\n  agentId: string;\n  runType: NondeterminismRunType;\n  kValue: number;\n  status: NondeterminismRunStatus;\n  traceCount: number;\n  criterionId?: string;\n  criteriaIds: string[];\n  temperature?: string;\n  model?: string;\n  progressPercent: number;\n  passAtKRate?: string;\n  passToKRate?: string;\n  avgVariance?: string;\n  reliabilityScore?: string;\n  startedAt?: string;\n  completedAt?: string;\n  createdBy?: string;\n  createdAt: string;\n}\n\nexport interface NondeterminismSample {\n  id: string;\n  runId: string;\n  traceId: string;\n  criterionId: string;\n  sampleIndex: number;\n  score: string;\n  passed: boolean;\n  reasoning?: string;\n  confidence?: string;\n  tokensUsed?: number;\n  costUsd?: string;\n  model?: string;\n  temperature?: string;\n  latencyMs?: number;\n  error?: string;\n  createdAt: string;\n}\n\nexport interface CreateRunOptions {\n  agentId: string;\n  criterionId?: string;\n  criteriaIds?: string[];\n  kValue: number;\n  traceIds: string[];\n  runType?: NondeterminismRunType;\n  temperature?: number;\n  model?: string;\n}\n\nexport interface RecordSampleOptions {\n  runId: string;\n  traceId: string;\n  criterionId: string;\n  sampleIndex: number;\n  score: number;\n  passed: boolean;\n  reasoning?: string;\n  confidence?: number;\n  tokensUsed?: number;\n  costUsd?: number;\n  model?: string;\n  temperature?: number;\n  latencyMs?: number;\n  error?: string;\n}\n\nexport interface TraceAnalysis {\n  traceId: string;\n  samples: NondeterminismSample[];\n  passCount: number;\n  totalCount: number;\n  passRate: number;\n  scoreVariance: number;\n  meanScore: number;\n  isConsistent: boolean;\n}\n\nexport interface CriterionAnalysis {\n  criterionId: string;\n  traceAnalyses: TraceAnalysis[];\n  passAtKRate: number;\n  passToKRate: number;\n  reliabilityScore: number;\n  isReliable: boolean;\n  recommendation: string;\n}\n\nexport interface RunSummary {\n  run: NondeterminismRun;\n  traceAnalyses: TraceAnalysis[];\n  criterionAnalyses: CriterionAnalysis[];\n}\n\nexport interface ListRunsOptions {\n  agentId?: string;\n  status?: NondeterminismRunStatus;\n  limit?: number;\n  offset?: number;\n}\n\nexport interface PassAtKInfo {\n  concepts: {\n    passAtK: { name: string; description: string; formula: string; useCase: string };\n    passToK: { name: string; description: string; formula: string; useCase: string };\n    variance: { name: string; description: string; useCase: string };\n    reliability: { name: string; description: string; useCase: string };\n  };\n  recommendations: Record<string, string>;\n  defaults: { kValue: number; reliabilityThreshold: number; varianceThreshold: number };\n}\n\n// ============================================================================\n// NON-DETERMINISM API CLIENT\n// ============================================================================\n\n/**\n * Non-Determinism API client for pass@k analysis and reliability measurement\n */\nexport const nondeterminism = {\n  /**\n   * Create a new non-determinism analysis run\n   *\n   * @example\n   * ```typescript\n   * const run = await nondeterminism.createRun({\n   *   agentId: 'agent_123',\n   *   criterionId: 'criterion_456',\n   *   kValue: 5,\n   *   traceIds: ['trace_1', 'trace_2', 'trace_3'],\n   *   runType: 'pass_at_k',\n   * });\n   * ```\n   */\n  async createRun(options: CreateRunOptions): Promise<NondeterminismRun> {\n    return apiRequestWithData<NondeterminismRun>('/nondeterminism/runs', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get non-determinism runs\n   *\n   * @example\n   * ```typescript\n   * const runs = await nondeterminism.getRuns({ agentId: 'agent_123' });\n   * ```\n   */\n  async getRuns(options: ListRunsOptions = {}): Promise<NondeterminismRun[]> {\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.limit) params.set('limit', String(options.limit));\n    if (options.offset) params.set('offset', String(options.offset));\n\n    return apiRequestWithData<NondeterminismRun[]>(\n      `/nondeterminism/runs?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get a specific run\n   *\n   * @example\n   * ```typescript\n   * const run = await nondeterminism.getRun('run_123');\n   * ```\n   */\n  async getRun(runId: string): Promise<NondeterminismRun> {\n    return apiRequestWithData<NondeterminismRun>(\n      `/nondeterminism/runs/${runId}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Start a run\n   *\n   * @example\n   * ```typescript\n   * await nondeterminism.startRun('run_123');\n   * ```\n   */\n  async startRun(runId: string): Promise<void> {\n    await apiRequest(`/nondeterminism/runs/${runId}/start`, {\n      method: 'POST',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Complete a run\n   *\n   * @example\n   * ```typescript\n   * await nondeterminism.completeRun('run_123');\n   * ```\n   */\n  async completeRun(runId: string): Promise<void> {\n    await apiRequest(`/nondeterminism/runs/${runId}/complete`, {\n      method: 'POST',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Record a sample result\n   *\n   * @example\n   * ```typescript\n   * const sample = await nondeterminism.recordSample({\n   *   runId: 'run_123',\n   *   traceId: 'trace_456',\n   *   criterionId: 'criterion_789',\n   *   sampleIndex: 0,\n   *   score: 85,\n   *   passed: true,\n   *   reasoning: 'Response meets quality criteria',\n   * });\n   * ```\n   */\n  async recordSample(options: RecordSampleOptions): Promise<NondeterminismSample> {\n    return apiRequestWithData<NondeterminismSample>('/nondeterminism/samples', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get samples for a run\n   *\n   * @example\n   * ```typescript\n   * const samples = await nondeterminism.getSamples('run_123');\n   * ```\n   */\n  async getSamples(runId: string): Promise<NondeterminismSample[]> {\n    return apiRequestWithData<NondeterminismSample[]>(\n      `/nondeterminism/runs/${runId}/samples`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get run summary with analysis\n   *\n   * @example\n   * ```typescript\n   * const summary = await nondeterminism.getRunSummary('run_123');\n   * console.log(`Pass@k rate: ${summary.criterionAnalyses[0].passAtKRate}`);\n   * ```\n   */\n  async getRunSummary(runId: string): Promise<RunSummary> {\n    return apiRequestWithData<RunSummary>(\n      `/nondeterminism/runs/${runId}/summary`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Trigger analysis of a completed run\n   *\n   * @example\n   * ```typescript\n   * const summary = await nondeterminism.analyzeRun('run_123');\n   * ```\n   */\n  async analyzeRun(runId: string): Promise<RunSummary> {\n    return apiRequestWithData<RunSummary>(\n      `/nondeterminism/runs/${runId}/analyze`,\n      { method: 'POST', apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get information about pass@k analysis\n   *\n   * @example\n   * ```typescript\n   * const info = await nondeterminism.getInfo();\n   * console.log(info.concepts.passAtK.description);\n   * ```\n   */\n  async getInfo(): Promise<PassAtKInfo> {\n    return apiRequestWithData<PassAtKInfo>(\n      '/nondeterminism/info',\n      { apiVersion: 'v1' }\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate pass@k probability from pass rate\n *\n * @param passRate - Single-run pass rate (0-1)\n * @param k - Number of runs\n * @returns Probability that at least 1 of k runs passes\n *\n * @example\n * ```typescript\n * const passAtK = calculatePassAtK(0.7, 3); // ~0.973\n * ```\n */\nexport function calculatePassAtK(passRate: number, k: number): number {\n  return 1 - Math.pow(1 - passRate, k);\n}\n\n/**\n * Calculate pass^k probability from pass rate\n *\n * @param passRate - Single-run pass rate (0-1)\n * @param k - Number of runs\n * @returns Probability that all k runs pass\n *\n * @example\n * ```typescript\n * const passToK = calculatePassToK(0.7, 3); // ~0.343\n * ```\n */\nexport function calculatePassToK(passRate: number, k: number): number {\n  return Math.pow(passRate, k);\n}\n\n/**\n * Calculate required pass rate to achieve target pass@k\n *\n * @param targetPassAtK - Desired pass@k probability\n * @param k - Number of runs\n * @returns Required single-run pass rate\n *\n * @example\n * ```typescript\n * const requiredRate = requiredPassRateForPassAtK(0.95, 3); // ~0.632\n * ```\n */\nexport function requiredPassRateForPassAtK(targetPassAtK: number, k: number): number {\n  return 1 - Math.pow(1 - targetPassAtK, 1 / k);\n}\n\n/**\n * Determine if evaluation is reliable based on analysis\n *\n * @param analysis - Criterion analysis result\n * @param reliabilityThreshold - Minimum reliability score (default 0.8)\n * @returns Whether the evaluation is considered reliable\n */\nexport function isReliableEvaluation(\n  analysis: CriterionAnalysis,\n  reliabilityThreshold = 0.8\n): boolean {\n  return analysis.reliabilityScore >= reliabilityThreshold;\n}\n\n/**\n * Get recommendation based on reliability analysis\n *\n * @param analysis - Criterion analysis result\n * @returns Actionable recommendation string\n */\nexport function getReliabilityRecommendation(analysis: CriterionAnalysis): string {\n  if (analysis.reliabilityScore >= 0.9) {\n    return 'Evaluation is highly reliable. No changes needed.';\n  } else if (analysis.reliabilityScore >= 0.8) {\n    return 'Evaluation is reliable. Consider minor criteria refinements.';\n  } else if (analysis.reliabilityScore >= 0.6) {\n    return 'Evaluation has moderate reliability. Add more specific criteria or examples.';\n  } else {\n    return 'Evaluation is unreliable. Consider using deterministic checks or restructuring criteria.';\n  }\n}\n"]}