@thinkhive/sdk 2.0.0 → 3.0.0

package/MIGRATION.md

@@ -0,0 +1,274 @@
+# Migration Guide: v2.x to v3.0
+
+This guide helps you migrate from ThinkHive SDK v2.x to v3.0.
+
+## Breaking Changes
+
+### Package Name Change
+
+```diff
+- npm install thinkhive-sdk
++ npm install @thinkhive/sdk
+```
+
+Update your imports:
+
+```diff
+- import ThinkHive from 'thinkhive-sdk';
++ import ThinkHive from '@thinkhive/sdk';
+```
+
+### Minimum Node.js Version
+
+- **v2.x**: Node.js 16+
+- **v3.0**: Node.js 18+
+
+### Core Concepts Change
+
+v3 is **run-centric**, not trace-centric:
+
+| v2 Concept | v3 Concept |
+|------------|------------|
+| `trace` | `run` (atomic unit) |
+| `TraceOptions` | `RunOptions` |
+| `explainer.analyze()` | `runs.create()` + `claims.getRunAnalysis()` |
+| `businessContext` | `customerContext` (time-series snapshot) |
+| Analysis results | Claims (facts vs inferences) |
+
+## Migration Steps
+
+### 1. Update Initialization
+
+```typescript
+// v2
+import { init } from 'thinkhive-sdk';
+
+init({
+  apiKey: 'th_xxx',
+  serviceName: 'my-agent',
+});
+
+// v3
+import { init } from '@thinkhive/sdk';
+
+init({
+  apiKey: 'th_xxx',
+  serviceName: 'my-agent',
+  apiVersion: 'v3', // Default is v3
+});
+```
+
+### 2. Migrate Trace Creation to Runs
+
+```typescript
+// v2 - Trace-based
+import { explainer } from 'thinkhive-sdk';
+
+const result = await explainer.analyze({
+  userMessage: 'Help me with my order',
+  agentResponse: 'I found your order...',
+  outcome: 'success',
+  businessContext: {
+    customerId: 'cust_123',
+    transactionValue: 500,
+  },
+});
+
+// v3 - Run-based
+import { runs, claims } from '@thinkhive/sdk';
+
+// Create a run
+const run = await runs.create({
+  agentId: 'agent_123',
+  conversationMessages: [
+    { role: 'user', content: 'Help me with my order' },
+    { role: 'assistant', content: 'I found your order...' },
+  ],
+  outcome: 'resolved',
+  customerContext: {
+    customerId: 'cust_123',
+    arr: 50000,           // Customer ARR at run time
+    healthScore: 85,       // Health score at run time
+    capturedAt: new Date().toISOString(),
+  },
+});
+
+// Get analysis with claims (facts vs inferences)
+const analysis = await claims.getRunAnalysis(run.id);
+```
+
+### 3. Migrate Business Context to Customer Context Snapshots
+
+v3 uses **time-series snapshots** instead of current values:
+
+```typescript
+// v2 - Current values
+const result = await explainer.analyze({
+  userMessage: '...',
+  agentResponse: '...',
+  businessContext: {
+    customerId: 'cust_123',
+    transactionValue: 500,
+  },
+});
+
+// v3 - Point-in-time snapshots
+import { customerContext, runs } from '@thinkhive/sdk';
+
+// First, capture customer metrics
+const snapshot = await customerContext.captureSnapshot('cust_123', {
+  arr: 100000,
+  healthScore: 85,
+  segment: 'enterprise',
+});
+
+// Use the snapshot in your run
+const run = await runs.create({
+  agentId: 'agent_123',
+  conversationMessages: [...],
+  customerContext: {
+    customerId: 'cust_123',
+    arr: snapshot.arr,
+    healthScore: snapshot.healthScore,
+    capturedAt: snapshot.capturedAt,
+  },
+});
+```
+
+### 4. Migrate to Claims API (Facts vs Inferences)
+
+v3 separates facts from inferences:
+
+```typescript
+// v2 - Single analysis result
+const result = await explainer.analyze({...});
+console.log(result.summary);
+console.log(result.outcome.verdict);
+
+// v3 - Claims with evidence
+import { claims, isFact, isInference } from '@thinkhive/sdk';
+
+const analysis = await claims.getRunAnalysis(run.id);
+
+// Get all claims
+for (const claim of analysis.claims) {
+  console.log(`[${claim.claimType}] ${claim.claimText}`);
+  console.log(`Confidence: ${claim.confidence}`);
+
+  if (isFact(claim)) {
+    console.log('This is an observed fact');
+  } else if (isInference(claim)) {
+    console.log('This is an LLM inference');
+  }
+}
+
+// Get facts vs inferences summary
+const summary = await claims.summary({ runId: run.id });
+console.log(`Facts: ${summary.observed.count}`);
+console.log(`Inferences: ${summary.inferred.count}`);
+```
+
+### 5. Add Ticket Linking (New in v3)
+
+```typescript
+import { runs, generateZendeskMarker, linkRunToZendeskTicket } from '@thinkhive/sdk';
+
+// Method 1: Embed marker in agent response
+const run = await runs.create({
+  agentId: 'agent_123',
+  conversationMessages: [...],
+});
+
+const marker = generateZendeskMarker(run.id);
+const responseWithMarker = `Your order is on the way! ${marker}`;
+// Send responseWithMarker to Zendesk
+
+// Method 2: Explicit linking
+await linkRunToZendeskTicket(run.id, '12345');
+```
+
+### 6. Add Calibration Tracking (New in v3)
+
+```typescript
+import { calibration } from '@thinkhive/sdk';
+
+// Check calibration status
+const status = await calibration.status('agent_123', 'churn_risk');
+console.log(`Brier score: ${status.brierScore}`);
+console.log(`Is calibrated: ${status.isCalibrated}`);
+
+// Record prediction outcomes
+await calibration.recordOutcome({
+  runId: run.id,
+  predictionType: 'churn_risk',
+  predictedValue: 0.7,  // We predicted 70% churn risk
+  actualOutcome: 1,     // Customer did churn
+});
+```
+
+## Deprecated APIs
+
+The following v2 APIs still work but are deprecated:
+
+```typescript
+// Deprecated - use runs.create() + claims.getRunAnalysis()
+import { explainer } from '@thinkhive/sdk';
+const result = await explainer.analyze({...}); // Still works
+
+// Deprecated types
+import type { TraceOptions, BusinessContext } from '@thinkhive/sdk';
+// Use RunOptions, CustomerContextSnapshot instead
+```
+
+## New Instrumentation
+
+### OpenAI Assistants
+
+```typescript
+import { wrapAssistantRun } from '@thinkhive/sdk/instrumentation/openai';
+
+const run = await wrapAssistantRun(
+  () => openai.beta.threads.runs.create(threadId, { assistant_id: assistantId }),
+  { assistantId, threadId }
+);
+```
+
+### LangGraph
+
+```typescript
+import { wrapLangGraphNode, wrapLangGraphExecution } from '@thinkhive/sdk/instrumentation/langchain';
+
+// Wrap individual nodes
+workflow.addNode('agent', wrapLangGraphNode('agent', agentFunction));
+
+// Wrap entire workflow
+const result = await wrapLangGraphExecution('support_workflow', () =>
+  compiledGraph.invoke({ messages: [...] })
+);
+```
+
+## TypeScript Changes
+
+```typescript
+// v2 types
+import type { TraceOptions, SpanData, BusinessContext } from 'thinkhive-sdk';
+
+// v3 types
+import type {
+  RunOptions,
+  RunOutcome,
+  ConversationMessage,
+  CustomerContextSnapshot,
+  Claim,
+  ClaimType,
+  AnalysisResult,
+  LinkMethod,
+  CalibrationStatus,
+} from '@thinkhive/sdk';
+```
+
+## Need Help?
+
+- Documentation: https://docs.thinkhive.ai
+- API Reference: https://api.thinkhive.ai/docs
+- Support: support@thinkhive.ai

package/dist/api/calibration.d.ts

@@ -0,0 +1,168 @@
+/**
+ * ThinkHive SDK v3.0 - Calibration API
+ *
+ * Prediction accuracy tracking with Brier scores and calibration metrics
+ */
+import type { CalibrationStatus, CalibrationBucket, PredictionType } from '../core/types';
+/**
+ * Record outcome input
+ */
+export interface RecordOutcomeInput {
+    /** Run ID the prediction was made for */
+    runId: string;
+    /** Type of prediction */
+    predictionType: PredictionType;
+    /** The predicted value (0-1 for probabilities) */
+    predictedValue: number;
+    /** The actual outcome (0 or 1 for binary, or actual value) */
+    actualOutcome: number;
+    /** When the prediction was made */
+    predictedAt?: string;
+    /** When the outcome was observed */
+    observedAt?: string;
+}
+/**
+ * Calibration metrics
+ */
+export interface CalibrationMetrics {
+    agentId: string;
+    predictionType: PredictionType;
+    /** Brier score (lower is better, <0.1 is good) */
+    brierScore: number;
+    /** Expected Calibration Error */
+    ece: number;
+    /** Maximum Calibration Error */
+    mce: number;
+    /** Sample count */
+    sampleCount: number;
+    /** Is the model well-calibrated */
+    isCalibrated: boolean;
+    /** Reliability diagram data */
+    reliabilityDiagram: CalibrationBucket[];
+    /** Last updated */
+    lastUpdated: string;
+}
+/**
+ * Calibration API client for prediction accuracy tracking
+ */
+export declare const calibration: {
+    /**
+     * Get calibration status for an agent
+     *
+     * @example
+     * ```typescript
+     * const status = await calibration.status('agent_123', 'churn_risk');
+     * console.log(`Brier score: ${status.brierScore}`);
+     * console.log(`Is calibrated: ${status.isCalibrated}`);
+     * ```
+     */
+    status(agentId: string, predictionType: PredictionType): Promise<CalibrationStatus>;
+    /**
+     * Get all calibration metrics for an agent
+     *
+     * @example
+     * ```typescript
+     * const metrics = await calibration.allMetrics('agent_123');
+     * for (const m of metrics) {
+     *   console.log(`${m.predictionType}: Brier=${m.brierScore}`);
+     * }
+     * ```
+     */
+    allMetrics(agentId: string): Promise<CalibrationMetrics[]>;
+    /**
+     * Record a prediction outcome for calibration tracking
+     *
+     * @example
+     * ```typescript
+     * // Record a churn prediction outcome
+     * await calibration.recordOutcome({
+     *   runId: 'run_abc123',
+     *   predictionType: 'churn_risk',
+     *   predictedValue: 0.7,  // We predicted 70% churn risk
+     *   actualOutcome: 1,     // Customer did churn
+     * });
+     *
+     * // Record a resolution time prediction
+     * await calibration.recordOutcome({
+     *   runId: 'run_abc123',
+     *   predictionType: 'resolution_time',
+     *   predictedValue: 15,   // Predicted 15 minutes
+     *   actualOutcome: 22,    // Actual was 22 minutes
+     * });
+     * ```
+     */
+    recordOutcome(input: RecordOutcomeInput): Promise<{
+        recorded: boolean;
+        brierContribution: number;
+        message: string;
+    }>;
+    /**
+     * Trigger recalibration for an agent
+     *
+     * @example
+     * ```typescript
+     * const result = await calibration.retrain('agent_123', {
+     *   predictionTypes: ['churn_risk', 'escalation_risk'],
+     * });
+     * console.log(`Retrained: ${result.success}`);
+     * ```
+     */
+    retrain(agentId: string, options?: {
+        predictionTypes?: PredictionType[];
+        minSamples?: number;
+    }): Promise<{
+        success: boolean;
+        retrainedTypes: PredictionType[];
+        skippedTypes: Array<{
+            type: PredictionType;
+            reason: string;
+        }>;
+        newMetrics: CalibrationMetrics[];
+    }>;
+    /**
+     * Get reliability diagram data for visualization
+     *
+     * @example
+     * ```typescript
+     * const diagram = await calibration.reliabilityDiagram('agent_123', 'outcome');
+     * // Use diagram.buckets to plot predicted vs actual probabilities
+     * ```
+     */
+    reliabilityDiagram(agentId: string, predictionType: PredictionType): Promise<{
+        agentId: string;
+        predictionType: PredictionType;
+        buckets: CalibrationBucket[];
+        perfectCalibrationLine: Array<{
+            x: number;
+            y: number;
+        }>;
+    }>;
+};
+/**
+ * Calculate Brier score from predictions and outcomes
+ * Lower is better, <0.1 is considered good
+ */
+export declare function calculateBrierScore(predictions: Array<{
+    predicted: number;
+    actual: number;
+}>): number;
+/**
+ * Calculate Expected Calibration Error (ECE)
+ * Measures how well-calibrated predictions are across confidence buckets
+ */
+export declare function calculateECE(predictions: Array<{
+    predicted: number;
+    actual: number;
+}>, numBuckets?: number): number;
+/**
+ * Check if a model is well-calibrated based on Brier score
+ */
+export declare function isWellCalibrated(brierScore: number): boolean;
+/**
+ * Get calibration quality label
+ */
+export declare function getCalibrationQuality(brierScore: number): 'excellent' | 'good' | 'fair' | 'poor';
+/**
+ * Format Brier score for display
+ */
+export declare function formatBrierScore(score: number): string;

package/dist/api/calibration.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Calibration API
+ *
+ * Prediction accuracy tracking with Brier scores and calibration metrics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calibration = void 0;
+exports.calculateBrierScore = calculateBrierScore;
+exports.calculateECE = calculateECE;
+exports.isWellCalibrated = isWellCalibrated;
+exports.getCalibrationQuality = getCalibrationQuality;
+exports.formatBrierScore = formatBrierScore;
+const client_1 = require("../core/client");
+/**
+ * Calibration API client for prediction accuracy tracking
+ */
+exports.calibration = {
+    /**
+     * Get calibration status for an agent
+     *
+     * @example
+     * ```typescript
+     * const status = await calibration.status('agent_123', 'churn_risk');
+     * console.log(`Brier score: ${status.brierScore}`);
+     * console.log(`Is calibrated: ${status.isCalibrated}`);
+     * ```
+     */
+    async status(agentId, predictionType) {
+        return (0, client_1.apiRequestWithData)(`/calibration/status/${agentId}?predictionType=${predictionType}`);
+    },
+    /**
+     * Get all calibration metrics for an agent
+     *
+     * @example
+     * ```typescript
+     * const metrics = await calibration.allMetrics('agent_123');
+     * for (const m of metrics) {
+     *   console.log(`${m.predictionType}: Brier=${m.brierScore}`);
+     * }
+     * ```
+     */
+    async allMetrics(agentId) {
+        return (0, client_1.apiRequestWithData)(`/calibration/metrics/${agentId}`);
+    },
+    /**
+     * Record a prediction outcome for calibration tracking
+     *
+     * @example
+     * ```typescript
+     * // Record a churn prediction outcome
+     * await calibration.recordOutcome({
+     *   runId: 'run_abc123',
+     *   predictionType: 'churn_risk',
+     *   predictedValue: 0.7,  // We predicted 70% churn risk
+     *   actualOutcome: 1,     // Customer did churn
+     * });
+     *
+     * // Record a resolution time prediction
+     * await calibration.recordOutcome({
+     *   runId: 'run_abc123',
+     *   predictionType: 'resolution_time',
+     *   predictedValue: 15,   // Predicted 15 minutes
+     *   actualOutcome: 22,    // Actual was 22 minutes
+     * });
+     * ```
+     */
+    async recordOutcome(input) {
+        return (0, client_1.apiRequestWithData)('/calibration/record', {
+            method: 'POST',
+            body: {
+                ...input,
+                predictedAt: input.predictedAt || new Date().toISOString(),
+                observedAt: input.observedAt || new Date().toISOString(),
+            },
+        });
+    },
+    /**
+     * Trigger recalibration for an agent
+     *
+     * @example
+     * ```typescript
+     * const result = await calibration.retrain('agent_123', {
+     *   predictionTypes: ['churn_risk', 'escalation_risk'],
+     * });
+     * console.log(`Retrained: ${result.success}`);
+     * ```
+     */
+    async retrain(agentId, options = {}) {
+        return (0, client_1.apiRequestWithData)(`/calibration/retrain/${agentId}`, {
+            method: 'POST',
+            body: options,
+        });
+    },
+    /**
+     * Get reliability diagram data for visualization
+     *
+     * @example
+     * ```typescript
+     * const diagram = await calibration.reliabilityDiagram('agent_123', 'outcome');
+     * // Use diagram.buckets to plot predicted vs actual probabilities
+     * ```
+     */
+    async reliabilityDiagram(agentId, predictionType) {
+        return (0, client_1.apiRequestWithData)(`/calibration/diagram/${agentId}?predictionType=${predictionType}`);
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Calculate Brier score from predictions and outcomes
+ * Lower is better, <0.1 is considered good
+ */
+function calculateBrierScore(predictions) {
+    if (predictions.length === 0)
+        return 0;
+    const sum = predictions.reduce((acc, { predicted, actual }) => {
+        return acc + Math.pow(predicted - actual, 2);
+    }, 0);
+    return sum / predictions.length;
+}
+/**
+ * Calculate Expected Calibration Error (ECE)
+ * Measures how well-calibrated predictions are across confidence buckets
+ */
+function calculateECE(predictions, numBuckets = 10) {
+    if (predictions.length === 0)
+        return 0;
+    const buckets = [];
+    for (let i = 0; i < numBuckets; i++) {
+        buckets.push({ predictions: [], actuals: [] });
+    }
+    // Assign predictions to buckets
+    for (const { predicted, actual } of predictions) {
+        const bucketIndex = Math.min(Math.floor(predicted * numBuckets), numBuckets - 1);
+        buckets[bucketIndex].predictions.push(predicted);
+        buckets[bucketIndex].actuals.push(actual);
+    }
+    // Calculate ECE
+    let ece = 0;
+    for (const bucket of buckets) {
+        if (bucket.predictions.length === 0)
+            continue;
+        const avgPredicted = bucket.predictions.reduce((a, b) => a + b, 0) / bucket.predictions.length;
+        const avgActual = bucket.actuals.reduce((a, b) => a + b, 0) / bucket.actuals.length;
+        const weight = bucket.predictions.length / predictions.length;
+        ece += weight * Math.abs(avgPredicted - avgActual);
+    }
+    return ece;
+}
+/**
+ * Check if a model is well-calibrated based on Brier score
+ */
+function isWellCalibrated(brierScore) {
+    return brierScore < 0.1;
+}
+/**
+ * Get calibration quality label
+ */
+function getCalibrationQuality(brierScore) {
+    if (brierScore < 0.05)
+        return 'excellent';
+    if (brierScore < 0.1)
+        return 'good';
+    if (brierScore < 0.2)
+        return 'fair';
+    return 'poor';
+}
+/**
+ * Format Brier score for display
+ */
+function formatBrierScore(score) {
+    return score.toFixed(4);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calibration.js","sourceRoot":"","sources":["../../src/api/calibration.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Calibration API\n *\n * Prediction accuracy tracking with Brier scores and calibration metrics\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type {\n  CalibrationStatus,\n  CalibrationBucket,\n  PredictionType,\n  ApiResponse,\n} from '../core/types';\n\n// ============================================================================\n// CALIBRATION API CLIENT\n// ============================================================================\n\n/**\n * Record outcome input\n */\nexport interface RecordOutcomeInput {\n  /** Run ID the prediction was made for */\n  runId: string;\n  /** Type of prediction */\n  predictionType: PredictionType;\n  /** The predicted value (0-1 for probabilities) */\n  predictedValue: number;\n  /** The actual outcome (0 or 1 for binary, or actual value) */\n  actualOutcome: number;\n  /** When the prediction was made */\n  predictedAt?: string;\n  /** When the outcome was observed */\n  observedAt?: string;\n}\n\n/**\n * Calibration metrics\n */\nexport interface CalibrationMetrics {\n  agentId: string;\n  predictionType: PredictionType;\n  /** Brier score (lower is better, <0.1 is good) */\n  brierScore: number;\n  /** Expected Calibration Error */\n  ece: number;\n  /** Maximum Calibration Error */\n  mce: number;\n  /** Sample count */\n  sampleCount: number;\n  /** Is the model well-calibrated */\n  isCalibrated: boolean;\n  /** Reliability diagram data */\n  reliabilityDiagram: CalibrationBucket[];\n  /** Last updated */\n  lastUpdated: string;\n}\n\n/**\n * Calibration API client for prediction accuracy tracking\n */\nexport const calibration = {\n  /**\n   * Get calibration status for an agent\n   *\n   * @example\n   * ```typescript\n   * const status = await calibration.status('agent_123', 'churn_risk');\n   * console.log(`Brier score: ${status.brierScore}`);\n   * console.log(`Is calibrated: ${status.isCalibrated}`);\n   * ```\n   */\n  async status(\n    agentId: string,\n    predictionType: PredictionType\n  ): Promise<CalibrationStatus> {\n    return apiRequestWithData<CalibrationStatus>(\n      `/calibration/status/${agentId}?predictionType=${predictionType}`\n    );\n  },\n\n  /**\n   * Get all calibration metrics for an agent\n   *\n   * @example\n   * ```typescript\n   * const metrics = await calibration.allMetrics('agent_123');\n   * for (const m of metrics) {\n   *   console.log(`${m.predictionType}: Brier=${m.brierScore}`);\n   * }\n   * ```\n   */\n  async allMetrics(agentId: string): Promise<CalibrationMetrics[]> {\n    return apiRequestWithData<CalibrationMetrics[]>(\n      `/calibration/metrics/${agentId}`\n    );\n  },\n\n  /**\n   * Record a prediction outcome for calibration tracking\n   *\n   * @example\n   * ```typescript\n   * // Record a churn prediction outcome\n   * await calibration.recordOutcome({\n   *   runId: 'run_abc123',\n   *   predictionType: 'churn_risk',\n   *   predictedValue: 0.7,  // We predicted 70% churn risk\n   *   actualOutcome: 1,     // Customer did churn\n   * });\n   *\n   * // Record a resolution time prediction\n   * await calibration.recordOutcome({\n   *   runId: 'run_abc123',\n   *   predictionType: 'resolution_time',\n   *   predictedValue: 15,   // Predicted 15 minutes\n   *   actualOutcome: 22,    // Actual was 22 minutes\n   * });\n   * ```\n   */\n  async recordOutcome(input: RecordOutcomeInput): Promise<{\n    recorded: boolean;\n    brierContribution: number;\n    message: string;\n  }> {\n    return apiRequestWithData('/calibration/record', {\n      method: 'POST',\n      body: {\n        ...input,\n        predictedAt: input.predictedAt || new Date().toISOString(),\n        observedAt: input.observedAt || new Date().toISOString(),\n      },\n    });\n  },\n\n  /**\n   * Trigger recalibration for an agent\n   *\n   * @example\n   * ```typescript\n   * const result = await calibration.retrain('agent_123', {\n   *   predictionTypes: ['churn_risk', 'escalation_risk'],\n   * });\n   * console.log(`Retrained: ${result.success}`);\n   * ```\n   */\n  async retrain(\n    agentId: string,\n    options: {\n      predictionTypes?: PredictionType[];\n      minSamples?: number;\n    } = {}\n  ): Promise<{\n    success: boolean;\n    retrainedTypes: PredictionType[];\n    skippedTypes: Array<{ type: PredictionType; reason: string }>;\n    newMetrics: CalibrationMetrics[];\n  }> {\n    return apiRequestWithData(`/calibration/retrain/${agentId}`, {\n      method: 'POST',\n      body: options,\n    });\n  },\n\n  /**\n   * Get reliability diagram data for visualization\n   *\n   * @example\n   * ```typescript\n   * const diagram = await calibration.reliabilityDiagram('agent_123', 'outcome');\n   * // Use diagram.buckets to plot predicted vs actual probabilities\n   * ```\n   */\n  async reliabilityDiagram(\n    agentId: string,\n    predictionType: PredictionType\n  ): Promise<{\n    agentId: string;\n    predictionType: PredictionType;\n    buckets: CalibrationBucket[];\n    perfectCalibrationLine: Array<{ x: number; y: number }>;\n  }> {\n    return apiRequestWithData(\n      `/calibration/diagram/${agentId}?predictionType=${predictionType}`\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate Brier score from predictions and outcomes\n * Lower is better, <0.1 is considered good\n */\nexport function calculateBrierScore(\n  predictions: Array<{ predicted: number; actual: number }>\n): number {\n  if (predictions.length === 0) return 0;\n\n  const sum = predictions.reduce((acc, { predicted, actual }) => {\n    return acc + Math.pow(predicted - actual, 2);\n  }, 0);\n\n  return sum / predictions.length;\n}\n\n/**\n * Calculate Expected Calibration Error (ECE)\n * Measures how well-calibrated predictions are across confidence buckets\n */\nexport function calculateECE(\n  predictions: Array<{ predicted: number; actual: number }>,\n  numBuckets: number = 10\n): number {\n  if (predictions.length === 0) return 0;\n\n  const buckets: Array<{ predictions: number[]; actuals: number[] }> = [];\n  for (let i = 0; i < numBuckets; i++) {\n    buckets.push({ predictions: [], actuals: [] });\n  }\n\n  // Assign predictions to buckets\n  for (const { predicted, actual } of predictions) {\n    const bucketIndex = Math.min(\n      Math.floor(predicted * numBuckets),\n      numBuckets - 1\n    );\n    buckets[bucketIndex].predictions.push(predicted);\n    buckets[bucketIndex].actuals.push(actual);\n  }\n\n  // Calculate ECE\n  let ece = 0;\n  for (const bucket of buckets) {\n    if (bucket.predictions.length === 0) continue;\n\n    const avgPredicted =\n      bucket.predictions.reduce((a, b) => a + b, 0) / bucket.predictions.length;\n    const avgActual =\n      bucket.actuals.reduce((a, b) => a + b, 0) / bucket.actuals.length;\n    const weight = bucket.predictions.length / predictions.length;\n\n    ece += weight * Math.abs(avgPredicted - avgActual);\n  }\n\n  return ece;\n}\n\n/**\n * Check if a model is well-calibrated based on Brier score\n */\nexport function isWellCalibrated(brierScore: number): boolean {\n  return brierScore < 0.1;\n}\n\n/**\n * Get calibration quality label\n */\nexport function getCalibrationQuality(\n  brierScore: number\n): 'excellent' | 'good' | 'fair' | 'poor' {\n  if (brierScore < 0.05) return 'excellent';\n  if (brierScore < 0.1) return 'good';\n  if (brierScore < 0.2) return 'fair';\n  return 'poor';\n}\n\n/**\n * Format Brier score for display\n */\nexport function formatBrierScore(score: number): string {\n  return score.toFixed(4);\n}\n"]}