@thinkhive/sdk 3.1.1 → 4.0.0

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

@@ -0,0 +1,200 @@
+/**
+ * ThinkHive SDK v3.0 - Conversation Evaluation API
+ *
+ * API for multi-turn conversation evaluation
+ */
+export type AggregateMethod = 'worst' | 'average' | 'weighted' | 'final_turn' | 'majority';
+export interface SessionTrace {
+    id: string;
+    sessionId: string;
+    turnNumber: number;
+    userMessage: string;
+    agentResponse: string;
+    timestamp: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TurnEvaluation {
+    traceId: string;
+    turnNumber: number;
+    passed: boolean;
+    score: number;
+    reasoning: string;
+}
+export interface ConversationEvalResult {
+    sessionId: string;
+    criterionId: string;
+    turnCount: number;
+    turnResults: TurnEvaluation[];
+    aggregatePassed: boolean;
+    aggregateScore: number;
+    aggregateMethod: AggregateMethod;
+    reasoning: string;
+    metadata?: Record<string, unknown>;
+}
+export interface EvaluateConversationOptions {
+    sessionId: string;
+    criterionId: string;
+    options?: {
+        aggregateMethod?: AggregateMethod;
+        minTurns?: number;
+        maxTurns?: number;
+    };
+}
+export interface AggregationMethodInfo {
+    id: AggregateMethod;
+    name: string;
+    description: string;
+    useCase: string;
+}
+/**
+ * Conversation Evaluation API client for multi-turn evaluation
+ */
+export declare const conversationEval: {
+    /**
+     * Get traces for a conversation session
+     *
+     * @example
+     * ```typescript
+     * const traces = await conversationEval.getSessionTraces('session_123');
+     * console.log(`Conversation has ${traces.length} turns`);
+     * ```
+     */
+    getSessionTraces(sessionId: string): Promise<SessionTrace[]>;
+    /**
+     * Run conversation-level evaluation
+     *
+     * @example
+     * ```typescript
+     * const result = await conversationEval.evaluate({
+     *   sessionId: 'session_123',
+     *   criterionId: 'criterion_456',
+     *   options: {
+     *     aggregateMethod: 'average',
+     *     minTurns: 2,
+     *   },
+     * });
+     * console.log(`Conversation score: ${result.aggregateScore}`);
+     * ```
+     */
+    evaluate(options: EvaluateConversationOptions): Promise<ConversationEvalResult>;
+    /**
+     * Get available aggregation methods with descriptions
+     *
+     * @example
+     * ```typescript
+     * const methods = await conversationEval.getAggregationMethods();
+     * for (const method of methods) {
+     *   console.log(`${method.name}: ${method.description}`);
+     * }
+     * ```
+     */
+    getAggregationMethods(): Promise<AggregationMethodInfo[]>;
+};
+/**
+ * Calculate worst-turn aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using worst turn logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateWorst(turnResults);
+ * // Fails if any turn fails
+ * ```
+ */
+export declare function aggregateWorst(turnResults: TurnEvaluation[]): {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Calculate average aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using average logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateAverage(turnResults);
+ * ```
+ */
+export declare function aggregateAverage(turnResults: TurnEvaluation[]): {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Calculate weighted average aggregation (later turns weighted more)
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using weighted average logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateWeighted(turnResults);
+ * // Later turns have higher weight
+ * ```
+ */
+export declare function aggregateWeighted(turnResults: TurnEvaluation[]): {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Calculate final-turn aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using only the final turn
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateFinalTurn(turnResults);
+ * // Only final turn matters
+ * ```
+ */
+export declare function aggregateFinalTurn(turnResults: TurnEvaluation[]): {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Calculate majority vote aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using majority vote logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateMajority(turnResults);
+ * // Passes if majority of turns pass
+ * ```
+ */
+export declare function aggregateMajority(turnResults: TurnEvaluation[]): {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Get appropriate aggregation function for a method
+ *
+ * @param method - Aggregation method name
+ * @returns Aggregation function
+ */
+export declare function getAggregator(method: AggregateMethod): (turnResults: TurnEvaluation[]) => {
+    passed: boolean;
+    score: number;
+};
+/**
+ * Find problematic turns in a conversation
+ *
+ * @param result - Conversation evaluation result
+ * @param scoreThreshold - Minimum acceptable score (default 70)
+ * @returns Array of problematic turn results
+ */
+export declare function getProblematicTurns(result: ConversationEvalResult, scoreThreshold?: number): TurnEvaluation[];
+/**
+ * Calculate conversation quality trend
+ *
+ * @param result - Conversation evaluation result
+ * @returns Trend analysis
+ */
+export declare function analyzeConversationTrend(result: ConversationEvalResult): {
+    direction: 'improving' | 'declining' | 'stable';
+    firstHalfAvg: number;
+    secondHalfAvg: number;
+};

package/dist/api/conversation-eval.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Conversation Evaluation API
+ *
+ * API for multi-turn conversation evaluation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conversationEval = void 0;
+exports.aggregateWorst = aggregateWorst;
+exports.aggregateAverage = aggregateAverage;
+exports.aggregateWeighted = aggregateWeighted;
+exports.aggregateFinalTurn = aggregateFinalTurn;
+exports.aggregateMajority = aggregateMajority;
+exports.getAggregator = getAggregator;
+exports.getProblematicTurns = getProblematicTurns;
+exports.analyzeConversationTrend = analyzeConversationTrend;
+const client_1 = require("../core/client");
+// ============================================================================
+// CONVERSATION EVAL API CLIENT
+// ============================================================================
+/**
+ * Conversation Evaluation API client for multi-turn evaluation
+ */
+exports.conversationEval = {
+    /**
+     * Get traces for a conversation session
+     *
+     * @example
+     * ```typescript
+     * const traces = await conversationEval.getSessionTraces('session_123');
+     * console.log(`Conversation has ${traces.length} turns`);
+     * ```
+     */
+    async getSessionTraces(sessionId) {
+        return (0, client_1.apiRequestWithData)(`/conversation-eval/traces?sessionId=${sessionId}`, { apiVersion: 'none' });
+    },
+    /**
+     * Run conversation-level evaluation
+     *
+     * @example
+     * ```typescript
+     * const result = await conversationEval.evaluate({
+     *   sessionId: 'session_123',
+     *   criterionId: 'criterion_456',
+     *   options: {
+     *     aggregateMethod: 'average',
+     *     minTurns: 2,
+     *   },
+     * });
+     * console.log(`Conversation score: ${result.aggregateScore}`);
+     * ```
+     */
+    async evaluate(options) {
+        return (0, client_1.apiRequestWithData)('/conversation-eval/evaluate', {
+            method: 'POST',
+            body: options,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get available aggregation methods with descriptions
+     *
+     * @example
+     * ```typescript
+     * const methods = await conversationEval.getAggregationMethods();
+     * for (const method of methods) {
+     *   console.log(`${method.name}: ${method.description}`);
+     * }
+     * ```
+     */
+    async getAggregationMethods() {
+        return (0, client_1.apiRequestWithData)('/conversation-eval/aggregation-methods', { apiVersion: 'none' });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Calculate worst-turn aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using worst turn logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateWorst(turnResults);
+ * // Fails if any turn fails
+ * ```
+ */
+function aggregateWorst(turnResults) {
+    if (turnResults.length === 0)
+        return { passed: false, score: 0 };
+    const worstScore = Math.min(...turnResults.map(t => t.score));
+    const passed = turnResults.every(t => t.passed);
+    return { passed, score: worstScore };
+}
+/**
+ * Calculate average aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using average logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateAverage(turnResults);
+ * ```
+ */
+function aggregateAverage(turnResults) {
+    if (turnResults.length === 0)
+        return { passed: false, score: 0 };
+    const avgScore = turnResults.reduce((sum, t) => sum + t.score, 0) / turnResults.length;
+    const passedCount = turnResults.filter(t => t.passed).length;
+    const passed = passedCount > turnResults.length / 2;
+    return { passed, score: avgScore };
+}
+/**
+ * Calculate weighted average aggregation (later turns weighted more)
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using weighted average logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateWeighted(turnResults);
+ * // Later turns have higher weight
+ * ```
+ */
+function aggregateWeighted(turnResults) {
+    if (turnResults.length === 0)
+        return { passed: false, score: 0 };
+    // Linear weights: 1, 2, 3, ...
+    let weightedSum = 0;
+    let weightTotal = 0;
+    let weightedPassSum = 0;
+    turnResults.forEach((turn, index) => {
+        const weight = index + 1;
+        weightedSum += turn.score * weight;
+        weightedPassSum += (turn.passed ? 1 : 0) * weight;
+        weightTotal += weight;
+    });
+    const avgScore = weightedSum / weightTotal;
+    const passed = (weightedPassSum / weightTotal) > 0.5;
+    return { passed, score: avgScore };
+}
+/**
+ * Calculate final-turn aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using only the final turn
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateFinalTurn(turnResults);
+ * // Only final turn matters
+ * ```
+ */
+function aggregateFinalTurn(turnResults) {
+    if (turnResults.length === 0)
+        return { passed: false, score: 0 };
+    const finalTurn = turnResults[turnResults.length - 1];
+    return { passed: finalTurn.passed, score: finalTurn.score };
+}
+/**
+ * Calculate majority vote aggregation
+ *
+ * @param turnResults - Array of turn evaluation results
+ * @returns Aggregated result using majority vote logic
+ *
+ * @example
+ * ```typescript
+ * const result = aggregateMajority(turnResults);
+ * // Passes if majority of turns pass
+ * ```
+ */
+function aggregateMajority(turnResults) {
+    if (turnResults.length === 0)
+        return { passed: false, score: 0 };
+    const passedCount = turnResults.filter(t => t.passed).length;
+    const passed = passedCount > turnResults.length / 2;
+    const avgScore = turnResults.reduce((sum, t) => sum + t.score, 0) / turnResults.length;
+    return { passed, score: avgScore };
+}
+/**
+ * Get appropriate aggregation function for a method
+ *
+ * @param method - Aggregation method name
+ * @returns Aggregation function
+ */
+function getAggregator(method) {
+    switch (method) {
+        case 'worst': return aggregateWorst;
+        case 'average': return aggregateAverage;
+        case 'weighted': return aggregateWeighted;
+        case 'final_turn': return aggregateFinalTurn;
+        case 'majority': return aggregateMajority;
+        default: return aggregateAverage;
+    }
+}
+/**
+ * Find problematic turns in a conversation
+ *
+ * @param result - Conversation evaluation result
+ * @param scoreThreshold - Minimum acceptable score (default 70)
+ * @returns Array of problematic turn results
+ */
+function getProblematicTurns(result, scoreThreshold = 70) {
+    return result.turnResults.filter(t => !t.passed || t.score < scoreThreshold);
+}
+/**
+ * Calculate conversation quality trend
+ *
+ * @param result - Conversation evaluation result
+ * @returns Trend analysis
+ */
+function analyzeConversationTrend(result) {
+    const turns = result.turnResults;
+    if (turns.length < 2) {
+        return { direction: 'stable', firstHalfAvg: 0, secondHalfAvg: 0 };
+    }
+    const midpoint = Math.floor(turns.length / 2);
+    const firstHalf = turns.slice(0, midpoint);
+    const secondHalf = turns.slice(midpoint);
+    const firstHalfAvg = firstHalf.reduce((sum, t) => sum + t.score, 0) / firstHalf.length;
+    const secondHalfAvg = secondHalf.reduce((sum, t) => sum + t.score, 0) / secondHalf.length;
+    const diff = secondHalfAvg - firstHalfAvg;
+    let direction;
+    if (diff > 5)
+        direction = 'improving';
+    else if (diff < -5)
+        direction = 'declining';
+    else
+        direction = 'stable';
+    return { direction, firstHalfAvg, secondHalfAvg };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"conversation-eval.js","sourceRoot":"","sources":["../../src/api/conversation-eval.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Conversation Evaluation API\n *\n * API for multi-turn conversation evaluation\n */\n\nimport { apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type AggregateMethod = 'worst' | 'average' | 'weighted' | 'final_turn' | 'majority';\n\nexport interface SessionTrace {\n  id: string;\n  sessionId: string;\n  turnNumber: number;\n  userMessage: string;\n  agentResponse: string;\n  timestamp: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface TurnEvaluation {\n  traceId: string;\n  turnNumber: number;\n  passed: boolean;\n  score: number;\n  reasoning: string;\n}\n\nexport interface ConversationEvalResult {\n  sessionId: string;\n  criterionId: string;\n  turnCount: number;\n  turnResults: TurnEvaluation[];\n  aggregatePassed: boolean;\n  aggregateScore: number;\n  aggregateMethod: AggregateMethod;\n  reasoning: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface EvaluateConversationOptions {\n  sessionId: string;\n  criterionId: string;\n  options?: {\n    aggregateMethod?: AggregateMethod;\n    minTurns?: number;\n    maxTurns?: number;\n  };\n}\n\nexport interface AggregationMethodInfo {\n  id: AggregateMethod;\n  name: string;\n  description: string;\n  useCase: string;\n}\n\n// ============================================================================\n// CONVERSATION EVAL API CLIENT\n// ============================================================================\n\n/**\n * Conversation Evaluation API client for multi-turn evaluation\n */\nexport const conversationEval = {\n  /**\n   * Get traces for a conversation session\n   *\n   * @example\n   * ```typescript\n   * const traces = await conversationEval.getSessionTraces('session_123');\n   * console.log(`Conversation has ${traces.length} turns`);\n   * ```\n   */\n  async getSessionTraces(sessionId: string): Promise<SessionTrace[]> {\n    return apiRequestWithData<SessionTrace[]>(\n      `/conversation-eval/traces?sessionId=${sessionId}`,\n      { apiVersion: 'none' }\n    );\n  },\n\n  /**\n   * Run conversation-level evaluation\n   *\n   * @example\n   * ```typescript\n   * const result = await conversationEval.evaluate({\n   *   sessionId: 'session_123',\n   *   criterionId: 'criterion_456',\n   *   options: {\n   *     aggregateMethod: 'average',\n   *     minTurns: 2,\n   *   },\n   * });\n   * console.log(`Conversation score: ${result.aggregateScore}`);\n   * ```\n   */\n  async evaluate(options: EvaluateConversationOptions): Promise<ConversationEvalResult> {\n    return apiRequestWithData<ConversationEvalResult>('/conversation-eval/evaluate', {\n      method: 'POST',\n      body: options,\n      apiVersion: 'none',\n    });\n  },\n\n  /**\n   * Get available aggregation methods with descriptions\n   *\n   * @example\n   * ```typescript\n   * const methods = await conversationEval.getAggregationMethods();\n   * for (const method of methods) {\n   *   console.log(`${method.name}: ${method.description}`);\n   * }\n   * ```\n   */\n  async getAggregationMethods(): Promise<AggregationMethodInfo[]> {\n    return apiRequestWithData<AggregationMethodInfo[]>(\n      '/conversation-eval/aggregation-methods',\n      { apiVersion: 'none' }\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate worst-turn aggregation\n *\n * @param turnResults - Array of turn evaluation results\n * @returns Aggregated result using worst turn logic\n *\n * @example\n * ```typescript\n * const result = aggregateWorst(turnResults);\n * // Fails if any turn fails\n * ```\n */\nexport function aggregateWorst(turnResults: TurnEvaluation[]): { passed: boolean; score: number } {\n  if (turnResults.length === 0) return { passed: false, score: 0 };\n\n  const worstScore = Math.min(...turnResults.map(t => t.score));\n  const passed = turnResults.every(t => t.passed);\n\n  return { passed, score: worstScore };\n}\n\n/**\n * Calculate average aggregation\n *\n * @param turnResults - Array of turn evaluation results\n * @returns Aggregated result using average logic\n *\n * @example\n * ```typescript\n * const result = aggregateAverage(turnResults);\n * ```\n */\nexport function aggregateAverage(turnResults: TurnEvaluation[]): { passed: boolean; score: number } {\n  if (turnResults.length === 0) return { passed: false, score: 0 };\n\n  const avgScore = turnResults.reduce((sum, t) => sum + t.score, 0) / turnResults.length;\n  const passedCount = turnResults.filter(t => t.passed).length;\n  const passed = passedCount > turnResults.length / 2;\n\n  return { passed, score: avgScore };\n}\n\n/**\n * Calculate weighted average aggregation (later turns weighted more)\n *\n * @param turnResults - Array of turn evaluation results\n * @returns Aggregated result using weighted average logic\n *\n * @example\n * ```typescript\n * const result = aggregateWeighted(turnResults);\n * // Later turns have higher weight\n * ```\n */\nexport function aggregateWeighted(turnResults: TurnEvaluation[]): { passed: boolean; score: number } {\n  if (turnResults.length === 0) return { passed: false, score: 0 };\n\n  // Linear weights: 1, 2, 3, ...\n  let weightedSum = 0;\n  let weightTotal = 0;\n  let weightedPassSum = 0;\n\n  turnResults.forEach((turn, index) => {\n    const weight = index + 1;\n    weightedSum += turn.score * weight;\n    weightedPassSum += (turn.passed ? 1 : 0) * weight;\n    weightTotal += weight;\n  });\n\n  const avgScore = weightedSum / weightTotal;\n  const passed = (weightedPassSum / weightTotal) > 0.5;\n\n  return { passed, score: avgScore };\n}\n\n/**\n * Calculate final-turn aggregation\n *\n * @param turnResults - Array of turn evaluation results\n * @returns Aggregated result using only the final turn\n *\n * @example\n * ```typescript\n * const result = aggregateFinalTurn(turnResults);\n * // Only final turn matters\n * ```\n */\nexport function aggregateFinalTurn(turnResults: TurnEvaluation[]): { passed: boolean; score: number } {\n  if (turnResults.length === 0) return { passed: false, score: 0 };\n\n  const finalTurn = turnResults[turnResults.length - 1];\n  return { passed: finalTurn.passed, score: finalTurn.score };\n}\n\n/**\n * Calculate majority vote aggregation\n *\n * @param turnResults - Array of turn evaluation results\n * @returns Aggregated result using majority vote logic\n *\n * @example\n * ```typescript\n * const result = aggregateMajority(turnResults);\n * // Passes if majority of turns pass\n * ```\n */\nexport function aggregateMajority(turnResults: TurnEvaluation[]): { passed: boolean; score: number } {\n  if (turnResults.length === 0) return { passed: false, score: 0 };\n\n  const passedCount = turnResults.filter(t => t.passed).length;\n  const passed = passedCount > turnResults.length / 2;\n  const avgScore = turnResults.reduce((sum, t) => sum + t.score, 0) / turnResults.length;\n\n  return { passed, score: avgScore };\n}\n\n/**\n * Get appropriate aggregation function for a method\n *\n * @param method - Aggregation method name\n * @returns Aggregation function\n */\nexport function getAggregator(\n  method: AggregateMethod\n): (turnResults: TurnEvaluation[]) => { passed: boolean; score: number } {\n  switch (method) {\n    case 'worst': return aggregateWorst;\n    case 'average': return aggregateAverage;\n    case 'weighted': return aggregateWeighted;\n    case 'final_turn': return aggregateFinalTurn;\n    case 'majority': return aggregateMajority;\n    default: return aggregateAverage;\n  }\n}\n\n/**\n * Find problematic turns in a conversation\n *\n * @param result - Conversation evaluation result\n * @param scoreThreshold - Minimum acceptable score (default 70)\n * @returns Array of problematic turn results\n */\nexport function getProblematicTurns(\n  result: ConversationEvalResult,\n  scoreThreshold = 70\n): TurnEvaluation[] {\n  return result.turnResults.filter(t => !t.passed || t.score < scoreThreshold);\n}\n\n/**\n * Calculate conversation quality trend\n *\n * @param result - Conversation evaluation result\n * @returns Trend analysis\n */\nexport function analyzeConversationTrend(result: ConversationEvalResult): {\n  direction: 'improving' | 'declining' | 'stable';\n  firstHalfAvg: number;\n  secondHalfAvg: number;\n} {\n  const turns = result.turnResults;\n  if (turns.length < 2) {\n    return { direction: 'stable', firstHalfAvg: 0, secondHalfAvg: 0 };\n  }\n\n  const midpoint = Math.floor(turns.length / 2);\n  const firstHalf = turns.slice(0, midpoint);\n  const secondHalf = turns.slice(midpoint);\n\n  const firstHalfAvg = firstHalf.reduce((sum, t) => sum + t.score, 0) / firstHalf.length;\n  const secondHalfAvg = secondHalf.reduce((sum, t) => sum + t.score, 0) / secondHalf.length;\n\n  const diff = secondHalfAvg - firstHalfAvg;\n  let direction: 'improving' | 'declining' | 'stable';\n\n  if (diff > 5) direction = 'improving';\n  else if (diff < -5) direction = 'declining';\n  else direction = 'stable';\n\n  return { direction, firstHalfAvg, secondHalfAvg };\n}\n"]}

package/dist/api/deterministic-graders.d.ts

@@ -0,0 +1,205 @@
+/**
+ * ThinkHive SDK v3.0 - Deterministic Graders API
+ *
+ * API for running deterministic (code-based) evaluations
+ */
+export type RuleType = 'regex' | 'contains' | 'not_contains' | 'json_valid' | 'json_schema' | 'length' | 'pii_check' | 'sentiment' | 'latency' | 'token_count';
+export interface DeterministicEvalResult {
+    passed: boolean;
+    score: number;
+    reasoning: string;
+    ruleResults?: RuleResult[];
+    metadata?: Record<string, unknown>;
+}
+export interface RuleResult {
+    ruleId: string;
+    ruleName: string;
+    ruleType: RuleType;
+    passed: boolean;
+    score: number;
+    details?: string;
+}
+export interface EvaluateOptions {
+    traceId: string;
+    criterionId: string;
+}
+export interface BulkEvaluateOptions {
+    evaluations: Array<{
+        traceId: string;
+        criterionId: string;
+    }>;
+}
+export interface BulkEvaluateResult {
+    results: Array<{
+        traceId: string;
+        criterionId: string;
+        passed: boolean;
+        score: number;
+        error?: string;
+    }>;
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        passRate: number;
+    };
+}
+export interface RuleTypeInfo {
+    id: RuleType;
+    name: string;
+    description: string;
+    configFields: string[];
+}
+export interface RuleTemplate {
+    id: string;
+    name: string;
+    description: string;
+    ruleType: RuleType;
+    config: Record<string, unknown>;
+}
+/**
+ * Deterministic Graders API client for code-based evaluations
+ */
+export declare const deterministicGraders: {
+    /**
+     * Run deterministic evaluation on a single trace
+     *
+     * @example
+     * ```typescript
+     * const result = await deterministicGraders.evaluate({
+     *   traceId: 'trace_123',
+     *   criterionId: 'criterion_456',
+     * });
+     * console.log(`Passed: ${result.passed}, Score: ${result.score}`);
+     * ```
+     */
+    evaluate(options: EvaluateOptions): Promise<DeterministicEvalResult>;
+    /**
+     * Run deterministic evaluations on multiple traces
+     *
+     * @example
+     * ```typescript
+     * const { results, summary } = await deterministicGraders.bulkEvaluate({
+     *   evaluations: [
+     *     { traceId: 'trace_1', criterionId: 'criterion_456' },
+     *     { traceId: 'trace_2', criterionId: 'criterion_456' },
+     *     { traceId: 'trace_3', criterionId: 'criterion_456' },
+     *   ],
+     * });
+     * console.log(`Pass rate: ${summary.passRate * 100}%`);
+     * ```
+     */
+    bulkEvaluate(options: BulkEvaluateOptions): Promise<BulkEvaluateResult>;
+    /**
+     * Get available rule types with descriptions
+     *
+     * @example
+     * ```typescript
+     * const ruleTypes = await deterministicGraders.getRuleTypes();
+     * for (const type of ruleTypes) {
+     *   console.log(`${type.name}: ${type.description}`);
+     * }
+     * ```
+     */
+    getRuleTypes(): Promise<RuleTypeInfo[]>;
+    /**
+     * Get rule templates
+     *
+     * @example
+     * ```typescript
+     * const templates = await deterministicGraders.getTemplates();
+     * const noPiiTemplate = templates.find(t => t.id === 'no_pii');
+     * ```
+     */
+    getTemplates(): Promise<RuleTemplate[]>;
+};
+/**
+ * Create a regex rule configuration
+ *
+ * @param pattern - Regular expression pattern
+ * @param flags - Regex flags (default: 'gi')
+ * @returns Rule configuration object
+ *
+ * @example
+ * ```typescript
+ * const config = createRegexRule('\\b(error|fail)\\b', 'gi');
+ * ```
+ */
+export declare function createRegexRule(pattern: string, flags?: string): {
+    pattern: string;
+    flags: string;
+};
+/**
+ * Create a contains rule configuration
+ *
+ * @param values - Strings to check for
+ * @param caseSensitive - Whether comparison is case-sensitive
+ * @returns Rule configuration object
+ *
+ * @example
+ * ```typescript
+ * const config = createContainsRule(['hello', 'hi', 'hey'], false);
+ * ```
+ */
+export declare function createContainsRule(values: string[], caseSensitive?: boolean): {
+    values: string[];
+    caseSensitive: boolean;
+};
+/**
+ * Create a length rule configuration
+ *
+ * @param min - Minimum length (optional)
+ * @param max - Maximum length (optional)
+ * @returns Rule configuration object
+ *
+ * @example
+ * ```typescript
+ * const config = createLengthRule(50, 1000);
+ * ```
+ */
+export declare function createLengthRule(min?: number, max?: number): {
+    min?: number;
+    max?: number;
+};
+/**
+ * Create a JSON schema rule configuration
+ *
+ * @param schema - JSON Schema object
+ * @returns Rule configuration object
+ *
+ * @example
+ * ```typescript
+ * const config = createJsonSchemaRule({
+ *   type: 'object',
+ *   required: ['name', 'email'],
+ *   properties: {
+ *     name: { type: 'string' },
+ *     email: { type: 'string', format: 'email' },
+ *   },
+ * });
+ * ```
+ */
+export declare function createJsonSchemaRule(schema: Record<string, unknown>): {
+    schema: Record<string, unknown>;
+};
+/**
+ * Check if all rule results passed
+ *
+ * @param results - Array of rule results
+ * @returns Whether all rules passed
+ */
+export declare function allRulesPassed(results: RuleResult[]): boolean;
+/**
+ * Get failed rules from results
+ *
+ * @param results - Array of rule results
+ * @returns Array of failed rule results
+ */
+export declare function getFailedRules(results: RuleResult[]): RuleResult[];
+/**
+ * Calculate average score from rule results
+ *
+ * @param results - Array of rule results
+ * @returns Average score (0-100)
+ */
+export declare function calculateAverageScore(results: RuleResult[]): number;