@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/business-metrics.d.ts

@@ -0,0 +1,188 @@
+/**
+ * ThinkHive SDK v3.2 - Business Metrics API
+ *
+ * Industry-driven business metrics with historical tracking and external data support
+ */
+/**
+ * Metric trend information
+ */
+export interface MetricTrend {
+    direction: 'up' | 'down' | 'stable';
+    value: number;
+    isPositive: boolean;
+}
+/**
+ * Current metric status
+ */
+export type MetricStatus = 'ready' | 'insufficient_data' | 'awaiting_external' | 'stale';
+/**
+ * Current metric response from the API
+ */
+export interface CurrentMetricResponse {
+    metricName: string;
+    metricType: 'trace_calculated' | 'external';
+    value: number | null;
+    valueFormatted: string;
+    unit?: string;
+    status: MetricStatus;
+    statusMessage?: string;
+    trend?: MetricTrend;
+    traceCount?: number;
+    minTraceThreshold?: number;
+    progressPercent?: number;
+    lastExternalUpdate?: string;
+}
+/**
+ * Historical data point
+ */
+export interface MetricHistoryPoint {
+    periodStart: string;
+    periodEnd: string;
+    value: number;
+    valueFormatted?: string;
+    source: string;
+    traceCount?: number;
+}
+/**
+ * Historical summary statistics
+ */
+export interface MetricHistorySummary {
+    current: number | null;
+    previous: number | null;
+    changePercent: number | null;
+    isPositive: boolean;
+    dataPointCount: number;
+}
+/**
+ * Full history response
+ */
+export interface MetricHistoryResponse {
+    metricName: string;
+    unit: string;
+    higherIsBetter: boolean;
+    dataPoints: MetricHistoryPoint[];
+    summary: MetricHistorySummary;
+}
+/**
+ * Options for recording external metric values
+ */
+export interface RecordMetricOptions {
+    metricName: string;
+    value: number;
+    unit?: string;
+    periodStart: string | Date;
+    periodEnd: string | Date;
+    source?: string;
+    sourceDetails?: Record<string, unknown>;
+}
+/**
+ * Response from recording a metric value
+ */
+export interface RecordMetricResponse {
+    success: boolean;
+    id: string;
+    recordedAt: string;
+}
+/**
+ * Business Metrics API client for industry-driven metrics with historical tracking
+ */
+export declare const businessMetrics: {
+    /**
+     * Get current metric value with status information
+     *
+     * @example
+     * ```typescript
+     * const metric = await businessMetrics.current('agent_123', 'Deflection Rate');
+     * console.log(`${metric.metricName}: ${metric.valueFormatted}`);
+     *
+     * if (metric.status === 'insufficient_data') {
+     *   console.log(`Need ${metric.minTraceThreshold - metric.traceCount} more traces`);
+     * }
+     * ```
+     */
+    current(agentId: string, metricName?: string): Promise<CurrentMetricResponse>;
+    /**
+     * Get historical metric data for graphing
+     *
+     * @example
+     * ```typescript
+     * const history = await businessMetrics.history('agent_123', 'Deflection Rate', {
+     *   startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
+     *   endDate: new Date(),
+     *   granularity: 'daily',
+     * });
+     *
+     * console.log(`${history.dataPoints.length} data points`);
+     * console.log(`Change: ${history.summary.changePercent}%`);
+     * ```
+     */
+    history(agentId: string, metricName: string, options?: {
+        startDate?: string | Date;
+        endDate?: string | Date;
+        granularity?: "hourly" | "daily" | "weekly" | "monthly";
+    }): Promise<MetricHistoryResponse>;
+    /**
+     * Record an external metric value
+     *
+     * Use this to ingest metrics from external data sources (CRM, surveys, billing, etc.)
+     *
+     * @example
+     * ```typescript
+     * // Record CSAT score from survey system
+     * await businessMetrics.record('agent_123', {
+     *   metricName: 'CSAT/NPS',
+     *   value: 4.5,
+     *   unit: 'score',
+     *   periodStart: '2024-01-01T00:00:00Z',
+     *   periodEnd: '2024-01-07T23:59:59Z',
+     *   source: 'survey_system',
+     *   sourceDetails: { surveyId: 'survey_456', responseCount: 150 },
+     * });
+     * ```
+     */
+    record(agentId: string, options: RecordMetricOptions): Promise<RecordMetricResponse>;
+    /**
+     * Batch record multiple external metric values
+     *
+     * @example
+     * ```typescript
+     * await businessMetrics.recordBatch('agent_123', [
+     *   { metricName: 'CSAT/NPS', value: 4.5, ... },
+     *   { metricName: 'Hours Saved', value: 120, ... },
+     * ]);
+     * ```
+     */
+    recordBatch(agentId: string, metrics: RecordMetricOptions[]): Promise<RecordMetricResponse[]>;
+};
+/**
+ * Check if a metric is ready to display
+ */
+export declare function isMetricReady(metric: CurrentMetricResponse): boolean;
+/**
+ * Check if a metric needs more trace data
+ */
+export declare function needsMoreTraces(metric: CurrentMetricResponse): boolean;
+/**
+ * Check if a metric is waiting for external data
+ */
+export declare function awaitingExternalData(metric: CurrentMetricResponse): boolean;
+/**
+ * Check if metric data is stale
+ */
+export declare function isMetricStale(metric: CurrentMetricResponse): boolean;
+/**
+ * Get human-readable status message
+ */
+export declare function getStatusMessage(metric: CurrentMetricResponse): string;
+/**
+ * Calculate progress toward minimum trace threshold
+ */
+export declare function getTraceProgress(metric: CurrentMetricResponse): number;
+/**
+ * Format metric value for display based on unit
+ */
+export declare function formatMetricValue(value: number, unit: string): string;
+/**
+ * Get trend direction as emoji
+ */
+export declare function getTrendEmoji(trend: MetricTrend): string;

package/dist/api/business-metrics.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.2 - Business Metrics API
+ *
+ * Industry-driven business metrics with historical tracking and external data support
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.businessMetrics = void 0;
+exports.isMetricReady = isMetricReady;
+exports.needsMoreTraces = needsMoreTraces;
+exports.awaitingExternalData = awaitingExternalData;
+exports.isMetricStale = isMetricStale;
+exports.getStatusMessage = getStatusMessage;
+exports.getTraceProgress = getTraceProgress;
+exports.formatMetricValue = formatMetricValue;
+exports.getTrendEmoji = getTrendEmoji;
+const client_1 = require("../core/client");
+// ============================================================================
+// BUSINESS METRICS API CLIENT
+// ============================================================================
+/**
+ * Business Metrics API client for industry-driven metrics with historical tracking
+ */
+exports.businessMetrics = {
+    /**
+     * Get current metric value with status information
+     *
+     * @example
+     * ```typescript
+     * const metric = await businessMetrics.current('agent_123', 'Deflection Rate');
+     * console.log(`${metric.metricName}: ${metric.valueFormatted}`);
+     *
+     * if (metric.status === 'insufficient_data') {
+     *   console.log(`Need ${metric.minTraceThreshold - metric.traceCount} more traces`);
+     * }
+     * ```
+     */
+    async current(agentId, metricName) {
+        const params = new URLSearchParams();
+        if (metricName) {
+            params.set('metricName', metricName);
+        }
+        const queryString = params.toString();
+        const url = `/agents/${agentId}/metrics/current${queryString ? `?${queryString}` : ''}`;
+        return (0, client_1.apiRequestWithData)(url, { apiVersion: 'v3' });
+    },
+    /**
+     * Get historical metric data for graphing
+     *
+     * @example
+     * ```typescript
+     * const history = await businessMetrics.history('agent_123', 'Deflection Rate', {
+     *   startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),
+     *   endDate: new Date(),
+     *   granularity: 'daily',
+     * });
+     *
+     * console.log(`${history.dataPoints.length} data points`);
+     * console.log(`Change: ${history.summary.changePercent}%`);
+     * ```
+     */
+    async history(agentId, metricName, options = {}) {
+        const params = new URLSearchParams();
+        params.set('metricName', metricName);
+        if (options.startDate) {
+            params.set('startDate', new Date(options.startDate).toISOString());
+        }
+        if (options.endDate) {
+            params.set('endDate', new Date(options.endDate).toISOString());
+        }
+        if (options.granularity) {
+            params.set('granularity', options.granularity);
+        }
+        return (0, client_1.apiRequestWithData)(`/agents/${agentId}/metrics/history?${params.toString()}`, { apiVersion: 'v3' });
+    },
+    /**
+     * Record an external metric value
+     *
+     * Use this to ingest metrics from external data sources (CRM, surveys, billing, etc.)
+     *
+     * @example
+     * ```typescript
+     * // Record CSAT score from survey system
+     * await businessMetrics.record('agent_123', {
+     *   metricName: 'CSAT/NPS',
+     *   value: 4.5,
+     *   unit: 'score',
+     *   periodStart: '2024-01-01T00:00:00Z',
+     *   periodEnd: '2024-01-07T23:59:59Z',
+     *   source: 'survey_system',
+     *   sourceDetails: { surveyId: 'survey_456', responseCount: 150 },
+     * });
+     * ```
+     */
+    async record(agentId, options) {
+        const body = {
+            metricName: options.metricName,
+            value: options.value,
+            unit: options.unit,
+            periodStart: new Date(options.periodStart).toISOString(),
+            periodEnd: new Date(options.periodEnd).toISOString(),
+            source: options.source || 'api',
+            sourceDetails: options.sourceDetails,
+        };
+        const response = await (0, client_1.apiRequest)(`/agents/${agentId}/metrics/values`, {
+            method: 'POST',
+            body,
+            apiVersion: 'v3',
+        });
+        return response.data;
+    },
+    /**
+     * Batch record multiple external metric values
+     *
+     * @example
+     * ```typescript
+     * await businessMetrics.recordBatch('agent_123', [
+     *   { metricName: 'CSAT/NPS', value: 4.5, ... },
+     *   { metricName: 'Hours Saved', value: 120, ... },
+     * ]);
+     * ```
+     */
+    async recordBatch(agentId, metrics) {
+        const results = await Promise.all(metrics.map((metric) => this.record(agentId, metric)));
+        return results;
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a metric is ready to display
+ */
+function isMetricReady(metric) {
+    return metric.status === 'ready';
+}
+/**
+ * Check if a metric needs more trace data
+ */
+function needsMoreTraces(metric) {
+    return metric.status === 'insufficient_data';
+}
+/**
+ * Check if a metric is waiting for external data
+ */
+function awaitingExternalData(metric) {
+    return metric.status === 'awaiting_external';
+}
+/**
+ * Check if metric data is stale
+ */
+function isMetricStale(metric) {
+    return metric.status === 'stale';
+}
+/**
+ * Get human-readable status message
+ */
+function getStatusMessage(metric) {
+    switch (metric.status) {
+        case 'ready':
+            return 'Metric is up to date';
+        case 'insufficient_data':
+            return metric.statusMessage ||
+                `Need ${(metric.minTraceThreshold || 50) - (metric.traceCount || 0)} more traces`;
+        case 'awaiting_external':
+            return metric.statusMessage || 'Waiting for external data source';
+        case 'stale':
+            return metric.statusMessage || 'Data may be outdated';
+        default:
+            return 'Unknown status';
+    }
+}
+/**
+ * Calculate progress toward minimum trace threshold
+ */
+function getTraceProgress(metric) {
+    if (metric.status !== 'insufficient_data')
+        return 100;
+    return metric.progressPercent || 0;
+}
+/**
+ * Format metric value for display based on unit
+ */
+function formatMetricValue(value, unit) {
+    switch (unit) {
+        case '%':
+            return `${Math.round(value * 10) / 10}%`;
+        case '$':
+            return new Intl.NumberFormat('en-US', {
+                style: 'currency',
+                currency: 'USD',
+            }).format(value);
+        case 's':
+            return value < 60 ? `${Math.round(value)}s` : `${Math.round(value / 60)}m`;
+        case 'hrs':
+            return `${Math.round(value * 10) / 10} hrs`;
+        case 'score':
+            return value.toFixed(1);
+        default:
+            return String(Math.round(value * 100) / 100);
+    }
+}
+/**
+ * Get trend direction as emoji
+ */
+function getTrendEmoji(trend) {
+    if (trend.direction === 'up')
+        return trend.isPositive ? '📈' : '📉';
+    if (trend.direction === 'down')
+        return trend.isPositive ? '📈' : '📉';
+    return '➡️';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"business-metrics.js","sourceRoot":"","sources":["../../src/api/business-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.2 - Business Metrics API\n *\n * Industry-driven business metrics with historical tracking and external data support\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type { ApiResponse } from '../core/types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/**\n * Metric trend information\n */\nexport interface MetricTrend {\n  direction: 'up' | 'down' | 'stable';\n  value: number;\n  isPositive: boolean;\n}\n\n/**\n * Current metric status\n */\nexport type MetricStatus = 'ready' | 'insufficient_data' | 'awaiting_external' | 'stale';\n\n/**\n * Current metric response from the API\n */\nexport interface CurrentMetricResponse {\n  metricName: string;\n  metricType: 'trace_calculated' | 'external';\n  value: number | null;\n  valueFormatted: string;\n  unit?: string;\n  status: MetricStatus;\n  statusMessage?: string;\n  trend?: MetricTrend;\n  traceCount?: number;\n  minTraceThreshold?: number;\n  progressPercent?: number;\n  lastExternalUpdate?: string;\n}\n\n/**\n * Historical data point\n */\nexport interface MetricHistoryPoint {\n  periodStart: string;\n  periodEnd: string;\n  value: number;\n  valueFormatted?: string;\n  source: string;\n  traceCount?: number;\n}\n\n/**\n * Historical summary statistics\n */\nexport interface MetricHistorySummary {\n  current: number | null;\n  previous: number | null;\n  changePercent: number | null;\n  isPositive: boolean;\n  dataPointCount: number;\n}\n\n/**\n * Full history response\n */\nexport interface MetricHistoryResponse {\n  metricName: string;\n  unit: string;\n  higherIsBetter: boolean;\n  dataPoints: MetricHistoryPoint[];\n  summary: MetricHistorySummary;\n}\n\n/**\n * Options for recording external metric values\n */\nexport interface RecordMetricOptions {\n  metricName: string;\n  value: number;\n  unit?: string;\n  periodStart: string | Date;\n  periodEnd: string | Date;\n  source?: string;\n  sourceDetails?: Record<string, unknown>;\n}\n\n/**\n * Response from recording a metric value\n */\nexport interface RecordMetricResponse {\n  success: boolean;\n  id: string;\n  recordedAt: string;\n}\n\n// ============================================================================\n// BUSINESS METRICS API CLIENT\n// ============================================================================\n\n/**\n * Business Metrics API client for industry-driven metrics with historical tracking\n */\nexport const businessMetrics = {\n  /**\n   * Get current metric value with status information\n   *\n   * @example\n   * ```typescript\n   * const metric = await businessMetrics.current('agent_123', 'Deflection Rate');\n   * console.log(`${metric.metricName}: ${metric.valueFormatted}`);\n   *\n   * if (metric.status === 'insufficient_data') {\n   *   console.log(`Need ${metric.minTraceThreshold - metric.traceCount} more traces`);\n   * }\n   * ```\n   */\n  async current(\n    agentId: string,\n    metricName?: string\n  ): Promise<CurrentMetricResponse> {\n    const params = new URLSearchParams();\n    if (metricName) {\n      params.set('metricName', metricName);\n    }\n\n    const queryString = params.toString();\n    const url = `/agents/${agentId}/metrics/current${queryString ? `?${queryString}` : ''}`;\n\n    return apiRequestWithData<CurrentMetricResponse>(url, { apiVersion: 'v3' });\n  },\n\n  /**\n   * Get historical metric data for graphing\n   *\n   * @example\n   * ```typescript\n   * const history = await businessMetrics.history('agent_123', 'Deflection Rate', {\n   *   startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000),\n   *   endDate: new Date(),\n   *   granularity: 'daily',\n   * });\n   *\n   * console.log(`${history.dataPoints.length} data points`);\n   * console.log(`Change: ${history.summary.changePercent}%`);\n   * ```\n   */\n  async history(\n    agentId: string,\n    metricName: string,\n    options: {\n      startDate?: string | Date;\n      endDate?: string | Date;\n      granularity?: 'hourly' | 'daily' | 'weekly' | 'monthly';\n    } = {}\n  ): Promise<MetricHistoryResponse> {\n    const params = new URLSearchParams();\n    params.set('metricName', metricName);\n\n    if (options.startDate) {\n      params.set('startDate', new Date(options.startDate).toISOString());\n    }\n    if (options.endDate) {\n      params.set('endDate', new Date(options.endDate).toISOString());\n    }\n    if (options.granularity) {\n      params.set('granularity', options.granularity);\n    }\n\n    return apiRequestWithData<MetricHistoryResponse>(\n      `/agents/${agentId}/metrics/history?${params.toString()}`,\n      { apiVersion: 'v3' }\n    );\n  },\n\n  /**\n   * Record an external metric value\n   *\n   * Use this to ingest metrics from external data sources (CRM, surveys, billing, etc.)\n   *\n   * @example\n   * ```typescript\n   * // Record CSAT score from survey system\n   * await businessMetrics.record('agent_123', {\n   *   metricName: 'CSAT/NPS',\n   *   value: 4.5,\n   *   unit: 'score',\n   *   periodStart: '2024-01-01T00:00:00Z',\n   *   periodEnd: '2024-01-07T23:59:59Z',\n   *   source: 'survey_system',\n   *   sourceDetails: { surveyId: 'survey_456', responseCount: 150 },\n   * });\n   * ```\n   */\n  async record(\n    agentId: string,\n    options: RecordMetricOptions\n  ): Promise<RecordMetricResponse> {\n    const body = {\n      metricName: options.metricName,\n      value: options.value,\n      unit: options.unit,\n      periodStart: new Date(options.periodStart).toISOString(),\n      periodEnd: new Date(options.periodEnd).toISOString(),\n      source: options.source || 'api',\n      sourceDetails: options.sourceDetails,\n    };\n\n    const response = await apiRequest<ApiResponse<RecordMetricResponse>>(\n      `/agents/${agentId}/metrics/values`,\n      {\n        method: 'POST',\n        body,\n        apiVersion: 'v3',\n      }\n    );\n\n    return response.data!;\n  },\n\n  /**\n   * Batch record multiple external metric values\n   *\n   * @example\n   * ```typescript\n   * await businessMetrics.recordBatch('agent_123', [\n   *   { metricName: 'CSAT/NPS', value: 4.5, ... },\n   *   { metricName: 'Hours Saved', value: 120, ... },\n   * ]);\n   * ```\n   */\n  async recordBatch(\n    agentId: string,\n    metrics: RecordMetricOptions[]\n  ): Promise<RecordMetricResponse[]> {\n    const results = await Promise.all(\n      metrics.map((metric) => this.record(agentId, metric))\n    );\n    return results;\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if a metric is ready to display\n */\nexport function isMetricReady(metric: CurrentMetricResponse): boolean {\n  return metric.status === 'ready';\n}\n\n/**\n * Check if a metric needs more trace data\n */\nexport function needsMoreTraces(metric: CurrentMetricResponse): boolean {\n  return metric.status === 'insufficient_data';\n}\n\n/**\n * Check if a metric is waiting for external data\n */\nexport function awaitingExternalData(metric: CurrentMetricResponse): boolean {\n  return metric.status === 'awaiting_external';\n}\n\n/**\n * Check if metric data is stale\n */\nexport function isMetricStale(metric: CurrentMetricResponse): boolean {\n  return metric.status === 'stale';\n}\n\n/**\n * Get human-readable status message\n */\nexport function getStatusMessage(metric: CurrentMetricResponse): string {\n  switch (metric.status) {\n    case 'ready':\n      return 'Metric is up to date';\n    case 'insufficient_data':\n      return metric.statusMessage ||\n        `Need ${(metric.minTraceThreshold || 50) - (metric.traceCount || 0)} more traces`;\n    case 'awaiting_external':\n      return metric.statusMessage || 'Waiting for external data source';\n    case 'stale':\n      return metric.statusMessage || 'Data may be outdated';\n    default:\n      return 'Unknown status';\n  }\n}\n\n/**\n * Calculate progress toward minimum trace threshold\n */\nexport function getTraceProgress(metric: CurrentMetricResponse): number {\n  if (metric.status !== 'insufficient_data') return 100;\n  return metric.progressPercent || 0;\n}\n\n/**\n * Format metric value for display based on unit\n */\nexport function formatMetricValue(value: number, unit: string): string {\n  switch (unit) {\n    case '%':\n      return `${Math.round(value * 10) / 10}%`;\n    case '$':\n      return new Intl.NumberFormat('en-US', {\n        style: 'currency',\n        currency: 'USD',\n      }).format(value);\n    case 's':\n      return value < 60 ? `${Math.round(value)}s` : `${Math.round(value / 60)}m`;\n    case 'hrs':\n      return `${Math.round(value * 10) / 10} hrs`;\n    case 'score':\n      return value.toFixed(1);\n    default:\n      return String(Math.round(value * 100) / 100);\n  }\n}\n\n/**\n * Get trend direction as emoji\n */\nexport function getTrendEmoji(trend: MetricTrend): string {\n  if (trend.direction === 'up') return trend.isPositive ? '📈' : '📉';\n  if (trend.direction === 'down') return trend.isPositive ? '📈' : '📉';\n  return '➡️';\n}\n"]}

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;
+};