@thinkhive/sdk 2.0.1 → 3.1.0

package/dist/index.d.ts

@@ -1,145 +1,25 @@
 /**
- * ThinkHive TypeScript SDK
- * OpenTelemetry-based observability for AI agents with Explainer integration
+ * ThinkHive SDK v3.0.0
  *
- * @version 2.0.0
+ * Run-centric AI agent observability platform with:
+ * - Facts vs Inferences (claims API)
+ * - Deterministic ticket linking (7 methods)
+ * - Customer context snapshots (time-series)
+ * - Calibrated predictions (Brier scores)
+ *
+ * @version 3.0.0
+ * @license MIT
  */
-export interface InitOptions {
-    /** ThinkHive API key (starts with th_) */
-    apiKey?: string;
-    /** Agent ID for legacy authentication */
-    agentId?: string;
-    /** ThinkHive API endpoint */
-    endpoint?: string;
-    /** Service name for traces */
-    serviceName?: string;
-    /** Enable auto-instrumentation */
-    autoInstrument?: boolean;
-    /** Frameworks to auto-instrument */
-    frameworks?: Array<'langchain' | 'openai' | 'anthropic' | 'llamaindex'>;
-    /** Enable debug logging */
-    debug?: boolean;
-}
-export interface TraceOptions {
-    /** User's message/query */
-    userMessage: string;
-    /** Agent's response */
-    agentResponse: string;
-    /** User's detected intent */
-    userIntent?: string;
-    /** Outcome: success, failure, partial_success */
-    outcome?: 'success' | 'failure' | 'partial_success';
-    /** Duration in milliseconds */
-    duration?: number;
-    /** Session ID for conversation tracking */
-    sessionId?: string;
-    /** Conversation history */
-    conversationHistory?: Array<{
-        role: string;
-        content: string;
-    }>;
-    /** Span data for detailed analysis */
-    spans?: SpanData[];
-    /** Business context for ROI calculation */
-    businessContext?: BusinessContext;
-    /** Custom metadata */
-    metadata?: Record<string, unknown>;
-}
-export interface SpanData {
-    id?: string;
-    name: string;
-    type: 'llm' | 'tool' | 'retrieval' | 'embedding' | 'chain' | 'custom';
-    startTime?: Date;
-    endTime?: Date;
-    durationMs?: number;
-    status?: 'ok' | 'error' | 'timeout';
-    error?: string;
-    input?: unknown;
-    output?: unknown;
-    model?: string;
-    provider?: string;
-    promptTokens?: number;
-    completionTokens?: number;
-    toolName?: string;
-    toolParameters?: Record<string, unknown>;
-    query?: string;
-    documentCount?: number;
-    topScore?: number;
-    sources?: string[];
-    children?: SpanData[];
-}
-export interface BusinessContext {
-    /** Customer ID */
-    customerId?: string;
-    /** Transaction value in dollars */
-    transactionValue?: number;
-    /** Priority level */
-    priority?: 'low' | 'medium' | 'high' | 'critical';
-    /** Department */
-    department?: string;
-    /** Industry vertical */
-    industry?: string;
-    /** Custom fields */
-    custom?: Record<string, unknown>;
-}
-export interface ExplainabilityResult {
-    traceId: string;
-    explainabilityId: string;
-    summary: string;
-    outcome: {
-        verdict: 'success' | 'partial_success' | 'failure';
-        confidence: number;
-        reasoning: string;
-    };
-    businessImpact: {
-        impactScore: number;
-        customerSatisfaction: number;
-        revenueRisk: string;
-    };
-    recommendations: Array<{
-        priority: string;
-        category: string;
-        action: string;
-        expectedImpact: string;
-    }>;
-    ragEvaluation?: {
-        groundedness: number;
-        faithfulness: number;
-        answerRelevance: number;
-    };
-    hallucinationReport?: {
-        detected: boolean;
-        types: string[];
-        severity: string;
-    };
-    processingTimeMs: number;
-}
-export interface AnalyzeOptions {
-    /** Force a specific analysis tier */
-    tier?: 'rule_based' | 'fast_llm' | 'full_llm' | 'deep';
-    /** Include RAG evaluation */
-    includeRagEvaluation?: boolean;
-    /** Include hallucination detection */
-    includeHallucinationCheck?: boolean;
-    /** Wait for analysis to complete (sync mode) */
-    waitForResult?: boolean;
-    /** Webhook URL for async notification */
-    webhookUrl?: string;
-}
-export interface FeedbackOptions {
-    /** Trace ID to provide feedback for */
-    traceId: string;
-    /** User rating (1-5) */
-    rating?: number;
-    /** Was the response helpful */
-    wasHelpful?: boolean;
-    /** Specific issues encountered */
-    issues?: Array<'slow_response' | 'incorrect' | 'unhelpful' | 'hallucination' | 'off_topic' | 'other'>;
-    /** Free-form comment */
-    comment?: string;
-}
+import { isInitialized, SDK_VERSION, DEFAULT_ENDPOINT } from './core/config';
+import { ThinkHiveApiError, ThinkHiveValidationError } from './core/client';
+import { runs, createRunWithContext, toOpenAIMessages, fromOpenAIMessages } from './api/runs';
+import { claims, isFact, isInference, isComputed, getHighConfidenceClaims, groupClaimsByType, groupClaimsByCategory } from './api/claims';
+import { calibration, calculateBrierScore, calculateECE, isWellCalibrated, getCalibrationQuality } from './api/calibration';
+import { linking, generateZendeskMarker, parseZendeskMarker, hasZendeskMarker, removeZendeskMarker, linkRunToTicket, linkRunToZendeskTicket, getBestLinkMethod, LINK_METHOD_CONFIDENCE } from './integrations/ticket-linking';
+import { customerContext, captureCustomerContext, getContextAsOf, toContextSnapshot, calculateArrChange, calculateHealthTrend } from './integrations/customer-context';
+export type { InitOptions, Framework, RunOptions, RunOutcome, ConversationMessage, CustomerContextSnapshot, TicketLinkingOptions, LinkMethod, TraceOptions, SpanData, BusinessContext, Claim, ClaimType, ClaimCategory, ConfidenceCalibration, EvidenceReference, AnalysisResult, CalibrationStatus, CalibrationBucket, PredictionType, RoiConfig, RoiSummary, ExplainabilityResult, ApiResponse, PaginatedResponse, RunResponse, } from './core/types';
 /**
- * Initialize ThinkHive SDK
+ * Initialize ThinkHive SDK v3
  *
  * @example
  * ```typescript
@@ -153,28 +33,17 @@ export interface FeedbackOptions {
  * });
  * ```
  */
-export declare function init(options?: InitOptions): void;
+export declare function init(options?: import('./core/types').InitOptions): void;
 /**
  * Get the global tracer
  */
 export declare function getTracer(): import("@opentelemetry/api").Tracer;
 /**
- * Check if SDK is initialized
+ * Shutdown the SDK and flush pending spans
  */
-export declare function isInitialized(): boolean;
+export declare function shutdown(): Promise<void>;
 /**
  * Trace an LLM call
- *
- * @example
- * ```typescript
- * const response = await traceLLM({
- *   name: 'chat_completion',
- *   modelName: 'gpt-4',
- *   provider: 'openai',
- * }, async () => {
- *   return await openai.chat.completions.create({ ... });
- * });
- * ```
  */
 export declare function traceLLM<T>(options: {
     name: string;
@@ -184,16 +53,6 @@ export declare function traceLLM<T>(options: {
 }, fn: () => Promise<T>): Promise<T>;
 /**
  * Trace a retrieval operation
- *
- * @example
- * ```typescript
- * const docs = await traceRetrieval({
- *   name: 'vector_search',
- *   query: 'What is the return policy?',
- * }, async () => {
- *   return await vectorStore.similaritySearch(query, 5);
- * });
- * ```
  */
 export declare function traceRetrieval<T>(options: {
     name: string;
@@ -202,17 +61,6 @@ export declare function traceRetrieval<T>(options: {
 }, fn: () => Promise<T>): Promise<T>;
 /**
  * Trace a tool call
- *
- * @example
- * ```typescript
- * const result = await traceTool({
- *   name: 'search_orders',
- *   toolName: 'OrderLookup',
- *   parameters: { orderId: '12345' },
- * }, async () => {
- *   return await orderService.lookup('12345');
- * });
- * ```
  */
 export declare function traceTool<T>(options: {
     name: string;
@@ -221,81 +69,40 @@ export declare function traceTool<T>(options: {
 }, fn: () => Promise<T>): Promise<T>;
 /**
  * Trace a chain/workflow
- *
- * @example
- * ```typescript
- * const result = await traceChain({
- *   name: 'customer_support_chain',
- * }, async () => {
- *   // Multiple LLM calls, tools, etc.
- * });
- * ```
  */
 export declare function traceChain<T>(options: {
     name: string;
     input?: unknown;
 }, fn: () => Promise<T>): Promise<T>;
 /**
- * Explainer API client for trace analysis
+ * Explainer API client (v2 compatibility)
+ * @deprecated Use runs and claims APIs instead
  */
 export declare const explainer: {
     /**
-     * Analyze a trace and get explainability insights
-     *
-     * @example
-     * ```typescript
-     * const result = await explainer.analyze({
-     *   userMessage: 'Help me with my order #12345',
-     *   agentResponse: 'I found your order...',
-     *   outcome: 'success',
-     *   spans: [
-     *     { name: 'order_lookup', type: 'tool', durationMs: 150 },
-     *     { name: 'gpt-4', type: 'llm', durationMs: 2500, model: 'gpt-4' },
-     *   ],
-     * });
-     * ```
+     * Analyze a trace (v2 format)
+     * @deprecated Use runs.create() + claims.getRunAnalysis() instead
      */
-    analyze(trace: TraceOptions, options?: AnalyzeOptions): Promise<ExplainabilityResult>;
-    /**
-     * Batch analyze multiple traces
-     *
-     * @example
-     * ```typescript
-     * const results = await explainer.analyzeBatch([
-     *   { userMessage: 'Q1', agentResponse: 'A1' },
-     *   { userMessage: 'Q2', agentResponse: 'A2' },
-     * ]);
-     * ```
-     */
-    analyzeBatch(traces: TraceOptions[], options?: AnalyzeOptions): Promise<{
-        results: ExplainabilityResult[];
-        summary: {
-            total: number;
-            successCount: number;
-            failureCount: number;
-            averageProcessingTime: number;
-        };
-    }>;
+    analyze(traceData: import("./core/types").TraceOptions, options?: {
+        tier?: string;
+        includeRagEvaluation?: boolean;
+        includeHallucinationCheck?: boolean;
+        waitForResult?: boolean;
+        webhookUrl?: string;
+    }): Promise<import("./core/types").ExplainabilityResult>;
     /**
      * Get a previously analyzed trace
+     * @deprecated
      */
-    get(traceId: string): Promise<ExplainabilityResult>;
+    get(traceId: string): Promise<import("./core/types").ExplainabilityResult>;
     /**
      * Search traces semantically
-     *
-     * @example
-     * ```typescript
-     * const results = await explainer.search({
-     *   query: 'order refund issues',
-     *   filters: { outcome: 'failure' },
-     *   limit: 10,
-     * });
-     * ```
+     * @deprecated
      */
     search(params: {
         query: string;
         filters?: {
-            outcome?: "success" | "failure" | "partial_success";
+            outcome?: string;
             minImpactScore?: number;
             dateRange?: {
                 from: Date;
@@ -304,207 +111,208 @@ export declare const explainer: {
         };
         limit?: number;
     }): Promise<{
-        results: Array<ExplainabilityResult & {
+        results: Array<import("./core/types").ExplainabilityResult & {
             similarity: number;
         }>;
         total: number;
     }>;
 };
-/**
- * Feedback API for improving analysis quality
- */
-export declare const feedback: {
-    /**
-     * Submit feedback for a trace
-     *
-     * @example
-     * ```typescript
-     * await feedback.submit({
-     *   traceId: 'trace_123',
-     *   rating: 5,
-     *   wasHelpful: true,
-     * });
-     * ```
-     */
-    submit(options: FeedbackOptions): Promise<{
-        success: boolean;
-    }>;
-};
-/**
- * Quality metrics API for RAG evaluation and hallucination detection
- */
-export declare const quality: {
-    /**
-     * Get RAG evaluation scores for a trace
-     */
-    getRagScores(traceId: string): Promise<{
-        contextRelevance: number;
-        contextPrecision: number;
-        contextRecall: number;
-        groundedness: number;
-        faithfulness: number;
-        answerRelevance: number;
-        citationAccuracy: number;
-        citationCompleteness: number;
-        overallGrade: string;
-    }>;
-    /**
-     * Get hallucination report for a trace
-     */
-    getHallucinationReport(traceId: string): Promise<{
-        hasHallucinations: boolean;
-        severity: "none" | "low" | "medium" | "high";
-        confidence: number;
-        detectedTypes: Array<{
-            type: string;
-            description: string;
-            evidence: string;
-            severity: string;
-        }>;
-    }>;
-    /**
-     * Evaluate RAG quality for custom input
-     */
-    evaluateRag(input: {
-        query: string;
-        response: string;
-        contexts: Array<{
-            content: string;
-            source?: string;
-            score?: number;
-        }>;
-    }): Promise<{
-        scores: Record<string, number>;
-        grade: string;
-        groundedSpans: string[];
-        ungroundedSpans: string[];
-    }>;
-};
-/**
- * ROI analytics API for business impact tracking
- */
-export declare const analytics: {
-    /**
-     * Get ROI summary for the account
-     */
-    getRoiSummary(): Promise<{
-        totalRevenueSaved: number;
-        supportCostReduction: number;
-        averageResolutionTime: number;
-        customerSatisfaction: number;
-        trends: Array<{
-            date: string;
-            revenueSaved: number;
-            tracesAnalyzed: number;
-        }>;
-    }>;
-    /**
-     * Get ROI by agent
-     */
-    getRoiByAgent(agentId: string): Promise<{
-        agentId: string;
-        revenueSaved: number;
-        tracesAnalyzed: number;
-        successRate: number;
-        topIssues: Array<{
-            issue: string;
-            count: number;
-            impact: number;
-        }>;
-    }>;
-    /**
-     * Get correlation analysis
-     */
-    getCorrelations(): Promise<{
-        correlations: Array<{
-            type: string;
-            coefficient: number;
-            description: string;
-            actionableInsight: string;
-        }>;
-    }>;
-};
-/**
- * Create a trace and analyze it in one call
- *
- * @example
- * ```typescript
- * const { trace, analysis } = await createAndAnalyze({
- *   userMessage: 'Help me track my order',
- *   agentResponse: 'Your order is on the way...',
- * });
- * ```
- */
-export declare function createAndAnalyze(traceData: TraceOptions, options?: AnalyzeOptions): Promise<{
-    trace: TraceOptions;
-    analysis: ExplainabilityResult;
-}>;
+export { isInitialized, SDK_VERSION, DEFAULT_ENDPOINT };
+export { runs, claims, calibration, linking, customerContext, };
+export { createRunWithContext, toOpenAIMessages, fromOpenAIMessages, isFact, isInference, isComputed, getHighConfidenceClaims, groupClaimsByType, groupClaimsByCategory, calculateBrierScore, calculateECE, isWellCalibrated, getCalibrationQuality, generateZendeskMarker, parseZendeskMarker, hasZendeskMarker, removeZendeskMarker, linkRunToTicket, linkRunToZendeskTicket, getBestLinkMethod, LINK_METHOD_CONFIDENCE, captureCustomerContext, getContextAsOf, toContextSnapshot, calculateArrChange, calculateHealthTrend, };
+export { ThinkHiveApiError, ThinkHiveValidationError };
 declare const _default: {
     init: typeof init;
     getTracer: typeof getTracer;
+    shutdown: typeof shutdown;
     isInitialized: typeof isInitialized;
     traceLLM: typeof traceLLM;
     traceRetrieval: typeof traceRetrieval;
     traceTool: typeof traceTool;
     traceChain: typeof traceChain;
+    runs: {
+        create(options: import("./core/types").RunOptions): Promise<import("./core/types").RunResponse>;
+        get(runId: string): Promise<import("./core/types").RunResponse>;
+        list(options?: import("./api/runs").ListRunsOptions): Promise<{
+            items: import("./core/types").RunResponse[];
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        }>;
+        update(runId: string, updates: Partial<Pick<import("./core/types").RunOptions, "outcome" | "outcomeReason" | "endedAt" | "metadata">>): Promise<import("./core/types").RunResponse>;
+        delete(runId: string): Promise<void>;
+        batch(runsData: import("./core/types").RunOptions[]): Promise<{
+            created: import("./core/types").RunResponse[];
+            failed: Array<{
+                index: number;
+                error: string;
+            }>;
+        }>;
+        stats(agentId: string, options?: {
+            from?: string | Date;
+            to?: string | Date;
+        }): Promise<import("./api/runs").RunStats>;
+        getTraces(runId: string): Promise<unknown[]>;
+        addTrace(runId: string, traceData: {
+            spans?: unknown[];
+            timestamp?: string;
+            metadata?: Record<string, unknown>;
+        }): Promise<{
+            traceId: string;
+        }>;
+    };
+    claims: {
+        createAnalysis(options: import("./api/claims").CreateAnalysisOptions): Promise<import("./core/types").AnalysisResult>;
+        getAnalysis(analysisId: string): Promise<import("./core/types").AnalysisResult>;
+        getRunAnalysis(runId: string): Promise<import("./core/types").AnalysisResult>;
+        getAnalysisHistory(runId: string): Promise<{
+            runId: string;
+            analyses: Array<{
+                id: string;
+                analysisVersion: string;
+                modelUsed: string;
+                outcomeVerdict: string;
+                isCurrent: boolean;
+                supersededBy?: string;
+                supersessionReason?: string;
+                analyzedAt: string;
+            }>;
+        }>;
+        supersedeAnalysis(analysisId: string, options: {
+            reason: string;
+            newAnalysis: Omit<import("./api/claims").CreateAnalysisOptions, "runId">;
+        }): Promise<{
+            supersededAnalysisId: string;
+            newAnalysis: import("./core/types").AnalysisResult;
+        }>;
+        list(options?: import("./api/claims").ListClaimsOptions): Promise<{
+            claims: import("./core/types").Claim[];
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        }>;
+        get(claimId: string): Promise<import("./core/types").Claim>;
+        verify(claimId: string, options: {
+            verdict: "confirmed" | "rejected" | "modified";
+            notes?: string;
+            modifiedText?: string;
+        }): Promise<{
+            claimId: string;
+            verdict: string;
+            message: string;
+        }>;
+        summary(options?: {
+            runId?: string;
+            analysisIds?: string[];
+        }): Promise<import("./api/claims").FactsVsInferencesSummary>;
+    };
+    calibration: {
+        status(agentId: string, predictionType: import("./core/types").PredictionType): Promise<import("./core/types").CalibrationStatus>;
+        allMetrics(agentId: string): Promise<import("./api/calibration").CalibrationMetrics[]>;
+        recordOutcome(input: import("./api/calibration").RecordOutcomeInput): Promise<{
+            recorded: boolean;
+            brierContribution: number;
+            message: string;
+        }>;
+        retrain(agentId: string, options?: {
+            predictionTypes?: import("./core/types").PredictionType[];
+            minSamples?: number;
+        }): Promise<{
+            success: boolean;
+            retrainedTypes: import("./core/types").PredictionType[];
+            skippedTypes: Array<{
+                type: import("./core/types").PredictionType;
+                reason: string;
+            }>;
+            newMetrics: import("./api/calibration").CalibrationMetrics[];
+        }>;
+        reliabilityDiagram(agentId: string, predictionType: import("./core/types").PredictionType): Promise<{
+            agentId: string;
+            predictionType: import("./core/types").PredictionType;
+            buckets: import("./core/types").CalibrationBucket[];
+            perfectCalibrationLine: Array<{
+                x: number;
+                y: number;
+            }>;
+        }>;
+    };
+    linking: {
+        create(input: import("./integrations/ticket-linking").CreateLinkInput): Promise<import("./integrations/ticket-linking").LinkResponse>;
+        getForRun(runId: string): Promise<import("./integrations/ticket-linking").LinkResponse[]>;
+        getForTicket(ticketId: string): Promise<import("./integrations/ticket-linking").LinkResponse[]>;
+        verify(linkId: string, options: {
+            verified: boolean;
+            notes?: string;
+        }): Promise<{
+            linkId: string;
+            verified: boolean;
+            message: string;
+        }>;
+        delete(linkId: string): Promise<void>;
+        autoLink(runId: string): Promise<{
+            runId: string;
+            created: import("./integrations/ticket-linking").LinkResponse[];
+            candidates: Array<{
+                ticketId: string;
+                method: import("./core/types").LinkMethod;
+                confidence: number;
+                reason: string;
+            }>;
+        }>;
+    };
+    customerContext: {
+        createAccount(input: {
+            name: string;
+            externalId?: string;
+            externalSource?: import("./integrations/customer-context").CustomerAccount["externalSource"];
+            domain?: string;
+            segment?: string;
+            industry?: string;
+            employeeCount?: number;
+        }): Promise<import("./integrations/customer-context").CustomerAccount>;
+        getAccount(customerId: string): Promise<import("./integrations/customer-context").CustomerAccount>;
+        getAccountByExternalId(externalId: string, source: import("./integrations/customer-context").CustomerAccount["externalSource"]): Promise<import("./integrations/customer-context").CustomerAccount | null>;
+        captureSnapshot(customerId: string, metrics: {
+            arr?: number;
+            healthScore?: number;
+            nps?: number;
+            segment?: string;
+            churnRisk?: "low" | "medium" | "high";
+            source?: string;
+        }): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot>;
+        getSnapshots(customerId: string, options?: {
+            from?: string;
+            to?: string;
+            limit?: number;
+        }): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot[]>;
+        getLatestSnapshot(customerId: string): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
+        getSnapshotAsOf(customerId: string, timestamp: string | Date): Promise<import("./integrations/customer-context").CustomerMetricsSnapshot | null>;
+    };
     explainer: {
         /**
-         * Analyze a trace and get explainability insights
-         *
-         * @example
-         * ```typescript
-         * const result = await explainer.analyze({
-         *   userMessage: 'Help me with my order #12345',
-         *   agentResponse: 'I found your order...',
-         *   outcome: 'success',
-         *   spans: [
-         *     { name: 'order_lookup', type: 'tool', durationMs: 150 },
-         *     { name: 'gpt-4', type: 'llm', durationMs: 2500, model: 'gpt-4' },
-         *   ],
-         * });
-         * ```
+         * Analyze a trace (v2 format)
+         * @deprecated Use runs.create() + claims.getRunAnalysis() instead
          */
-        analyze(trace: TraceOptions, options?: AnalyzeOptions): Promise<ExplainabilityResult>;
-        /**
-         * Batch analyze multiple traces
-         *
-         * @example
-         * ```typescript
-         * const results = await explainer.analyzeBatch([
-         *   { userMessage: 'Q1', agentResponse: 'A1' },
-         *   { userMessage: 'Q2', agentResponse: 'A2' },
-         * ]);
-         * ```
-         */
-        analyzeBatch(traces: TraceOptions[], options?: AnalyzeOptions): Promise<{
-            results: ExplainabilityResult[];
-            summary: {
-                total: number;
-                successCount: number;
-                failureCount: number;
-                averageProcessingTime: number;
-            };
-        }>;
+        analyze(traceData: import("./core/types").TraceOptions, options?: {
+            tier?: string;
+            includeRagEvaluation?: boolean;
+            includeHallucinationCheck?: boolean;
+            waitForResult?: boolean;
+            webhookUrl?: string;
+        }): Promise<import("./core/types").ExplainabilityResult>;
         /**
          * Get a previously analyzed trace
+         * @deprecated
          */
-        get(traceId: string): Promise<ExplainabilityResult>;
+        get(traceId: string): Promise<import("./core/types").ExplainabilityResult>;
         /**
          * Search traces semantically
-         *
-         * @example
-         * ```typescript
-         * const results = await explainer.search({
-         *   query: 'order refund issues',
-         *   filters: { outcome: 'failure' },
-         *   limit: 10,
-         * });
-         * ```
+         * @deprecated
          */
         search(params: {
             query: string;
             filters?: {
-                outcome?: "success" | "failure" | "partial_success";
+                outcome?: string;
                 minImpactScore?: number;
                 dateRange?: {
                     from: Date;
@@ -513,117 +321,19 @@ declare const _default: {
             };
             limit?: number;
         }): Promise<{
-            results: Array<ExplainabilityResult & {
+            results: Array<import("./core/types").ExplainabilityResult & {
                 similarity: number;
             }>;
             total: number;
         }>;
     };
-    feedback: {
-        /**
-         * Submit feedback for a trace
-         *
-         * @example
-         * ```typescript
-         * await feedback.submit({
-         *   traceId: 'trace_123',
-         *   rating: 5,
-         *   wasHelpful: true,
-         * });
-         * ```
-         */
-        submit(options: FeedbackOptions): Promise<{
-            success: boolean;
-        }>;
-    };
-    quality: {
-        /**
-         * Get RAG evaluation scores for a trace
-         */
-        getRagScores(traceId: string): Promise<{
-            contextRelevance: number;
-            contextPrecision: number;
-            contextRecall: number;
-            groundedness: number;
-            faithfulness: number;
-            answerRelevance: number;
-            citationAccuracy: number;
-            citationCompleteness: number;
-            overallGrade: string;
-        }>;
-        /**
-         * Get hallucination report for a trace
-         */
-        getHallucinationReport(traceId: string): Promise<{
-            hasHallucinations: boolean;
-            severity: "none" | "low" | "medium" | "high";
-            confidence: number;
-            detectedTypes: Array<{
-                type: string;
-                description: string;
-                evidence: string;
-                severity: string;
-            }>;
-        }>;
-        /**
-         * Evaluate RAG quality for custom input
-         */
-        evaluateRag(input: {
-            query: string;
-            response: string;
-            contexts: Array<{
-                content: string;
-                source?: string;
-                score?: number;
-            }>;
-        }): Promise<{
-            scores: Record<string, number>;
-            grade: string;
-            groundedSpans: string[];
-            ungroundedSpans: string[];
-        }>;
-    };
-    analytics: {
-        /**
-         * Get ROI summary for the account
-         */
-        getRoiSummary(): Promise<{
-            totalRevenueSaved: number;
-            supportCostReduction: number;
-            averageResolutionTime: number;
-            customerSatisfaction: number;
-            trends: Array<{
-                date: string;
-                revenueSaved: number;
-                tracesAnalyzed: number;
-            }>;
-        }>;
-        /**
-         * Get ROI by agent
-         */
-        getRoiByAgent(agentId: string): Promise<{
-            agentId: string;
-            revenueSaved: number;
-            tracesAnalyzed: number;
-            successRate: number;
-            topIssues: Array<{
-                issue: string;
-                count: number;
-                impact: number;
-            }>;
-        }>;
-        /**
-         * Get correlation analysis
-         */
-        getCorrelations(): Promise<{
-            correlations: Array<{
-                type: string;
-                coefficient: number;
-                description: string;
-                actionableInsight: string;
-            }>;
-        }>;
-    };
-    createAndAnalyze: typeof createAndAnalyze;
+    generateZendeskMarker: typeof generateZendeskMarker;
+    parseZendeskMarker: typeof parseZendeskMarker;
+    linkRunToTicket: typeof linkRunToTicket;
+    createRunWithContext: typeof createRunWithContext;
+    isFact: typeof isFact;
+    isInference: typeof isInference;
+    calculateBrierScore: typeof calculateBrierScore;
+    isWellCalibrated: typeof isWellCalibrated;
 };
 export default _default;