@thinkhive/sdk 2.0.1 → 3.0.0

package/dist/core/config.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_SERVICE_NAME = exports.DEFAULT_ENDPOINT = exports.SDK_VERSION = void 0;
+exports.initConfig = initConfig;
+exports.getConfig = getConfig;
+exports.isInitialized = isInitialized;
+exports.resetConfig = resetConfig;
+exports.debugLog = debugLog;
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+exports.SDK_VERSION = '3.0.0';
+exports.DEFAULT_ENDPOINT = 'https://thinkhivemind-h25z7pvd3q-uc.a.run.app';
+exports.DEFAULT_SERVICE_NAME = 'my-ai-agent';
+let config = null;
+let initialized = false;
+// ============================================================================
+// CONFIG FUNCTIONS
+// ============================================================================
+/**
+ * Initialize configuration from options
+ */
+function initConfig(options = {}) {
+    const apiKey = options.apiKey || process.env.THINKHIVE_API_KEY || '';
+    const agentId = options.agentId || process.env.THINKHIVE_AGENT_ID || '';
+    if (!apiKey && !agentId) {
+        throw new Error('Either apiKey or agentId must be provided (or set THINKHIVE_API_KEY env var)');
+    }
+    config = {
+        apiKey,
+        agentId,
+        endpoint: options.endpoint || process.env.THINKHIVE_ENDPOINT || exports.DEFAULT_ENDPOINT,
+        serviceName: options.serviceName || process.env.THINKHIVE_SERVICE_NAME || exports.DEFAULT_SERVICE_NAME,
+        autoInstrument: options.autoInstrument ?? false,
+        frameworks: options.frameworks || ['langchain', 'openai'],
+        debug: options.debug ?? false,
+        apiVersion: options.apiVersion ?? 'v3',
+    };
+    initialized = true;
+    return config;
+}
+/**
+ * Get current configuration
+ * @throws if not initialized
+ */
+function getConfig() {
+    if (!config || !initialized) {
+        throw new Error('ThinkHive SDK not initialized. Call init() first.');
+    }
+    return config;
+}
+/**
+ * Check if SDK is initialized
+ */
+function isInitialized() {
+    return initialized;
+}
+/**
+ * Reset configuration (for testing)
+ */
+function resetConfig() {
+    config = null;
+    initialized = false;
+}
+/**
+ * Debug log helper
+ */
+function debugLog(...args) {
+    if (config?.debug) {
+        console.log('[ThinkHive]', ...args);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/core/types.d.ts

@@ -0,0 +1,354 @@
+/**
+ * ThinkHive SDK v3.0 - Core Types
+ *
+ * Run-centric types with facts vs inferences and customer context snapshots
+ */
+export interface InitOptions {
+    /** ThinkHive API key (starts with th_) */
+    apiKey?: string;
+    /** Agent ID */
+    agentId?: string;
+    /** ThinkHive API endpoint */
+    endpoint?: string;
+    /** Service name for traces */
+    serviceName?: string;
+    /** Enable auto-instrumentation */
+    autoInstrument?: boolean;
+    /** Frameworks to auto-instrument */
+    frameworks?: Framework[];
+    /** Enable debug logging */
+    debug?: boolean;
+    /** API version (default: 'v3') */
+    apiVersion?: 'v1' | 'v3';
+}
+export type Framework = 'langchain' | 'langgraph' | 'openai' | 'openai-assistants' | 'anthropic' | 'llamaindex' | 'n8n' | 'voiceflow';
+/**
+ * Options for creating a run (v3 atomic unit)
+ */
+export interface RunOptions {
+    /** Agent ID */
+    agentId: string;
+    /** When the run started */
+    startedAt?: string | Date;
+    /** When the run ended */
+    endedAt?: string | Date;
+    /** Run outcome */
+    outcome?: RunOutcome;
+    /** Reason for the outcome */
+    outcomeReason?: string;
+    /** Conversation messages */
+    conversationMessages: ConversationMessage[];
+    /** Model ID used */
+    modelId?: string;
+    /** Prompt version */
+    promptVersion?: string;
+    /** Session ID for conversation tracking */
+    sessionId?: string;
+    /** Customer context snapshot (ARR, health AS OF this run) */
+    customerContext?: CustomerContextSnapshot;
+    /** Ticket linking options */
+    ticketLinking?: TicketLinkingOptions;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+}
+export type RunOutcome = 'resolved' | 'escalated' | 'abandoned' | 'failed' | 'transferred' | 'pending';
+export interface ConversationMessage {
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    timestamp?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Customer context captured AS OF the run time (not current values)
+ */
+export interface CustomerContextSnapshot {
+    /** Customer account ID */
+    customerId?: string;
+    /** ARR at the time of the run (not current ARR) */
+    arr?: number;
+    /** Health score at the time of the run (0-100) */
+    healthScore?: number;
+    /** Customer segment (e.g., 'enterprise', 'mid-market', 'smb') */
+    segment?: string;
+    /** When this snapshot was captured */
+    capturedAt?: string;
+    /** Custom fields (will be validated against schema) */
+    customFields?: Record<string, unknown>;
+}
+/**
+ * Options for deterministic ticket linking
+ */
+export interface TicketLinkingOptions {
+    /** Link method to use */
+    method: LinkMethod;
+    /** Ticket ID (for sdk_explicit method) */
+    ticketId?: string;
+    /** External ticket ID (e.g., Zendesk ticket ID) */
+    externalTicketId?: string;
+    /** Platform for external ticket */
+    platform?: 'zendesk' | 'intercom' | 'salesforce' | 'freshdesk';
+    /** Custom field name for linking */
+    customFieldName?: string;
+    /** Custom field value */
+    customFieldValue?: string;
+}
+export type LinkMethod = 'sdk_explicit' | 'zendesk_marker' | 'custom_field' | 'middleware_stamp' | 'session_match' | 'email_time_window' | 'manual';
+/**
+ * Trace options (v2 format, converted to runs internally)
+ * @deprecated Use RunOptions instead
+ */
+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[];
+}
+/**
+ * @deprecated Use CustomerContextSnapshot instead
+ */
+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>;
+}
+/**
+ * A claim about a run (fact vs inference)
+ */
+export interface Claim {
+    id: string;
+    analysisId: string;
+    /** Type of claim */
+    claimType: ClaimType;
+    /** Category of the claim */
+    claimCategory: ClaimCategory;
+    /** The claim text */
+    claimText: string;
+    /** Confidence in this claim (0-1) */
+    confidence: number;
+    /** How well calibrated is this confidence */
+    confidenceCalibration: ConfidenceCalibration;
+    /** Evidence supporting this claim */
+    evidence: EvidenceReference[];
+    /** Is this claim explainable to end users */
+    isExplainable: boolean;
+    /** Probability value for probability claims */
+    probabilityValue?: number;
+    /** Human-assigned verification status */
+    humanVerified?: boolean;
+    /** Human verification verdict */
+    humanVerdict?: 'confirmed' | 'rejected' | 'modified';
+    createdAt?: string;
+}
+export type ClaimType = 'observed' | 'inferred' | 'computed';
+export type ClaimCategory = 'outcome' | 'root_cause' | 'customer_impact' | 'churn_risk' | 'revenue_impact' | 'quality' | 'other';
+export type ConfidenceCalibration = 'calibrated' | 'uncalibrated' | 'needs_more_data';
+export interface EvidenceReference {
+    /** Type of evidence */
+    type: 'span' | 'message' | 'tool_call' | 'external' | 'computed';
+    /** ID of the referenced item */
+    referenceId: string;
+    /** How relevant is this evidence */
+    relevance: string;
+    /** Confidence in this evidence */
+    confidence: number;
+}
+export interface AnalysisResult {
+    id: string;
+    runId: string;
+    analysisVersion: string;
+    modelUsed: string;
+    /** Overall outcome verdict */
+    outcomeVerdict: 'success' | 'partial_success' | 'failure';
+    /** Confidence in the verdict (0-1) */
+    outcomeConfidence: number;
+    /** Root cause category if failure */
+    rootCauseCategory?: string;
+    /** Confidence in root cause (0-1) */
+    rootCauseConfidence?: number;
+    /** Is this the current analysis */
+    isCurrent: boolean;
+    /** ID of analysis that superseded this one */
+    supersededBy?: string;
+    /** Claims from this analysis */
+    claims: Claim[];
+    analyzedAt?: string;
+    createdAt?: string;
+}
+export interface CalibrationStatus {
+    agentId: string;
+    predictionType: PredictionType;
+    /** Brier score (lower is better, <0.1 is good) */
+    brierScore: number;
+    /** Expected Calibration Error */
+    ece: number;
+    /** Sample count */
+    sampleCount: number;
+    /** Is the model well-calibrated */
+    isCalibrated: boolean;
+    /** Calibration by confidence bucket */
+    buckets: CalibrationBucket[];
+    lastUpdated?: string;
+}
+export type PredictionType = 'outcome' | 'churn_risk' | 'escalation_risk' | 'resolution_time' | 'customer_satisfaction';
+export interface CalibrationBucket {
+    bucketStart: number;
+    bucketEnd: number;
+    predictedProbability: number;
+    actualFrequency: number;
+    sampleCount: number;
+}
+export interface RoiConfig {
+    /** Cost per support ticket deflected */
+    ticketDeflectionValue: number;
+    /** Cost per escalation */
+    escalationCost: number;
+    /** Cost per hour of agent time */
+    agentHourlyCost: number;
+    /** Average resolution time (minutes) */
+    avgResolutionMinutes: number;
+    /** CSAT impact multiplier */
+    csatImpactMultiplier: number;
+}
+export interface RoiSummary {
+    period: {
+        from: string;
+        to: string;
+    };
+    /** Total estimated savings */
+    totalSavings: number;
+    /** Breakdown by category */
+    breakdown: {
+        ticketDeflection: number;
+        escalationPrevention: number;
+        timeToResolution: number;
+        churnPrevention: number;
+    };
+    /** Confidence in these estimates */
+    confidence: 'low' | 'medium' | 'high';
+    /** Methodology used */
+    methodology: string;
+}
+/**
+ * @deprecated Use AnalysisResult instead
+ */
+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 ApiResponse<T> {
+    success: boolean;
+    data?: T;
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}
+export interface PaginatedResponse<T> {
+    success: boolean;
+    data: {
+        items: T[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+}
+export interface RunResponse {
+    id: string;
+    companyId: string;
+    agentId: string;
+    ticketId?: string;
+    customerAccountId?: string;
+    sessionId?: string;
+    startedAt: string;
+    endedAt?: string;
+    durationMs?: number;
+    outcome?: RunOutcome;
+    outcomeReason?: string;
+    conversationMessages: ConversationMessage[];
+    modelId?: string;
+    promptVersion?: string;
+    customerContextSnapshot?: CustomerContextSnapshot;
+    zendeskMarker?: string;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/core/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Core Types
+ *
+ * Run-centric types with facts vs inferences and customer context snapshots
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":";AAAA;;;;GAIG","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Core Types\n *\n * Run-centric types with facts vs inferences and customer context snapshots\n */\n\n// ============================================================================\n// INIT OPTIONS\n// ============================================================================\n\nexport interface InitOptions {\n  /** ThinkHive API key (starts with th_) */\n  apiKey?: string;\n  /** Agent ID */\n  agentId?: string;\n  /** ThinkHive API endpoint */\n  endpoint?: string;\n  /** Service name for traces */\n  serviceName?: string;\n  /** Enable auto-instrumentation */\n  autoInstrument?: boolean;\n  /** Frameworks to auto-instrument */\n  frameworks?: Framework[];\n  /** Enable debug logging */\n  debug?: boolean;\n  /** API version (default: 'v3') */\n  apiVersion?: 'v1' | 'v3';\n}\n\nexport type Framework =\n  | 'langchain'\n  | 'langgraph'\n  | 'openai'\n  | 'openai-assistants'\n  | 'anthropic'\n  | 'llamaindex'\n  | 'n8n'\n  | 'voiceflow';\n\n// ============================================================================\n// RUN OPTIONS (v3)\n// ============================================================================\n\n/**\n * Options for creating a run (v3 atomic unit)\n */\nexport interface RunOptions {\n  /** Agent ID */\n  agentId: string;\n  /** When the run started */\n  startedAt?: string | Date;\n  /** When the run ended */\n  endedAt?: string | Date;\n  /** Run outcome */\n  outcome?: RunOutcome;\n  /** Reason for the outcome */\n  outcomeReason?: string;\n  /** Conversation messages */\n  conversationMessages: ConversationMessage[];\n  /** Model ID used */\n  modelId?: string;\n  /** Prompt version */\n  promptVersion?: string;\n  /** Session ID for conversation tracking */\n  sessionId?: string;\n  /** Customer context snapshot (ARR, health AS OF this run) */\n  customerContext?: CustomerContextSnapshot;\n  /** Ticket linking options */\n  ticketLinking?: TicketLinkingOptions;\n  /** Custom metadata */\n  metadata?: Record<string, unknown>;\n}\n\nexport type RunOutcome =\n  | 'resolved'\n  | 'escalated'\n  | 'abandoned'\n  | 'failed'\n  | 'transferred'\n  | 'pending';\n\nexport interface ConversationMessage {\n  role: 'user' | 'assistant' | 'system' | 'tool';\n  content: string;\n  timestamp?: string;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// CUSTOMER CONTEXT SNAPSHOT (v3)\n// ============================================================================\n\n/**\n * Customer context captured AS OF the run time (not current values)\n */\nexport interface CustomerContextSnapshot {\n  /** Customer account ID */\n  customerId?: string;\n  /** ARR at the time of the run (not current ARR) */\n  arr?: number;\n  /** Health score at the time of the run (0-100) */\n  healthScore?: number;\n  /** Customer segment (e.g., 'enterprise', 'mid-market', 'smb') */\n  segment?: string;\n  /** When this snapshot was captured */\n  capturedAt?: string;\n  /** Custom fields (will be validated against schema) */\n  customFields?: Record<string, unknown>;\n}\n\n// ============================================================================\n// TICKET LINKING (v3)\n// ============================================================================\n\n/**\n * Options for deterministic ticket linking\n */\nexport interface TicketLinkingOptions {\n  /** Link method to use */\n  method: LinkMethod;\n  /** Ticket ID (for sdk_explicit method) */\n  ticketId?: string;\n  /** External ticket ID (e.g., Zendesk ticket ID) */\n  externalTicketId?: string;\n  /** Platform for external ticket */\n  platform?: 'zendesk' | 'intercom' | 'salesforce' | 'freshdesk';\n  /** Custom field name for linking */\n  customFieldName?: string;\n  /** Custom field value */\n  customFieldValue?: string;\n}\n\nexport type LinkMethod =\n  | 'sdk_explicit'      // Direct SDK call with ticket ID (confidence: 1.0)\n  | 'zendesk_marker'    // Embedded THID marker in response (confidence: 1.0)\n  | 'custom_field'      // Zendesk custom field (confidence: 1.0)\n  | 'middleware_stamp'  // Middleware-injected trace ID (confidence: 0.98)\n  | 'session_match'     // Session ID correlation (confidence: 0.95)\n  | 'email_time_window' // Email + 15min window (confidence: 0.6)\n  | 'manual';           // Human-assigned (confidence: 1.0)\n\n// ============================================================================\n// TRACE OPTIONS (v2 compatibility)\n// ============================================================================\n\n/**\n * Trace options (v2 format, converted to runs internally)\n * @deprecated Use RunOptions instead\n */\nexport interface TraceOptions {\n  /** User's message/query */\n  userMessage: string;\n  /** Agent's response */\n  agentResponse: string;\n  /** User's detected intent */\n  userIntent?: string;\n  /** Outcome: success, failure, partial_success */\n  outcome?: 'success' | 'failure' | 'partial_success';\n  /** Duration in milliseconds */\n  duration?: number;\n  /** Session ID for conversation tracking */\n  sessionId?: string;\n  /** Conversation history */\n  conversationHistory?: Array<{ role: string; content: string }>;\n  /** Span data for detailed analysis */\n  spans?: SpanData[];\n  /** Business context for ROI calculation */\n  businessContext?: BusinessContext;\n  /** Custom metadata */\n  metadata?: Record<string, unknown>;\n}\n\nexport interface SpanData {\n  id?: string;\n  name: string;\n  type: 'llm' | 'tool' | 'retrieval' | 'embedding' | 'chain' | 'custom';\n  startTime?: Date;\n  endTime?: Date;\n  durationMs?: number;\n  status?: 'ok' | 'error' | 'timeout';\n  error?: string;\n  input?: unknown;\n  output?: unknown;\n  // LLM-specific\n  model?: string;\n  provider?: string;\n  promptTokens?: number;\n  completionTokens?: number;\n  // Tool-specific\n  toolName?: string;\n  toolParameters?: Record<string, unknown>;\n  // Retrieval-specific\n  query?: string;\n  documentCount?: number;\n  topScore?: number;\n  sources?: string[];\n  // Children\n  children?: SpanData[];\n}\n\n/**\n * @deprecated Use CustomerContextSnapshot instead\n */\nexport interface BusinessContext {\n  /** Customer ID */\n  customerId?: string;\n  /** Transaction value in dollars */\n  transactionValue?: number;\n  /** Priority level */\n  priority?: 'low' | 'medium' | 'high' | 'critical';\n  /** Department */\n  department?: string;\n  /** Industry vertical */\n  industry?: string;\n  /** Custom fields */\n  custom?: Record<string, unknown>;\n}\n\n// ============================================================================\n// CLAIM TYPES (v3)\n// ============================================================================\n\n/**\n * A claim about a run (fact vs inference)\n */\nexport interface Claim {\n  id: string;\n  analysisId: string;\n  /** Type of claim */\n  claimType: ClaimType;\n  /** Category of the claim */\n  claimCategory: ClaimCategory;\n  /** The claim text */\n  claimText: string;\n  /** Confidence in this claim (0-1) */\n  confidence: number;\n  /** How well calibrated is this confidence */\n  confidenceCalibration: ConfidenceCalibration;\n  /** Evidence supporting this claim */\n  evidence: EvidenceReference[];\n  /** Is this claim explainable to end users */\n  isExplainable: boolean;\n  /** Probability value for probability claims */\n  probabilityValue?: number;\n  /** Human-assigned verification status */\n  humanVerified?: boolean;\n  /** Human verification verdict */\n  humanVerdict?: 'confirmed' | 'rejected' | 'modified';\n  createdAt?: string;\n}\n\nexport type ClaimType = 'observed' | 'inferred' | 'computed';\nexport type ClaimCategory =\n  | 'outcome'\n  | 'root_cause'\n  | 'customer_impact'\n  | 'churn_risk'\n  | 'revenue_impact'\n  | 'quality'\n  | 'other';\nexport type ConfidenceCalibration = 'calibrated' | 'uncalibrated' | 'needs_more_data';\n\nexport interface EvidenceReference {\n  /** Type of evidence */\n  type: 'span' | 'message' | 'tool_call' | 'external' | 'computed';\n  /** ID of the referenced item */\n  referenceId: string;\n  /** How relevant is this evidence */\n  relevance: string;\n  /** Confidence in this evidence */\n  confidence: number;\n}\n\n// ============================================================================\n// ANALYSIS RESULT (v3)\n// ============================================================================\n\nexport interface AnalysisResult {\n  id: string;\n  runId: string;\n  analysisVersion: string;\n  modelUsed: string;\n  /** Overall outcome verdict */\n  outcomeVerdict: 'success' | 'partial_success' | 'failure';\n  /** Confidence in the verdict (0-1) */\n  outcomeConfidence: number;\n  /** Root cause category if failure */\n  rootCauseCategory?: string;\n  /** Confidence in root cause (0-1) */\n  rootCauseConfidence?: number;\n  /** Is this the current analysis */\n  isCurrent: boolean;\n  /** ID of analysis that superseded this one */\n  supersededBy?: string;\n  /** Claims from this analysis */\n  claims: Claim[];\n  analyzedAt?: string;\n  createdAt?: string;\n}\n\n// ============================================================================\n// CALIBRATION TYPES (v3)\n// ============================================================================\n\nexport interface CalibrationStatus {\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  /** Sample count */\n  sampleCount: number;\n  /** Is the model well-calibrated */\n  isCalibrated: boolean;\n  /** Calibration by confidence bucket */\n  buckets: CalibrationBucket[];\n  lastUpdated?: string;\n}\n\nexport type PredictionType =\n  | 'outcome'\n  | 'churn_risk'\n  | 'escalation_risk'\n  | 'resolution_time'\n  | 'customer_satisfaction';\n\nexport interface CalibrationBucket {\n  bucketStart: number;\n  bucketEnd: number;\n  predictedProbability: number;\n  actualFrequency: number;\n  sampleCount: number;\n}\n\n// ============================================================================\n// ROI TYPES (v3)\n// ============================================================================\n\nexport interface RoiConfig {\n  /** Cost per support ticket deflected */\n  ticketDeflectionValue: number;\n  /** Cost per escalation */\n  escalationCost: number;\n  /** Cost per hour of agent time */\n  agentHourlyCost: number;\n  /** Average resolution time (minutes) */\n  avgResolutionMinutes: number;\n  /** CSAT impact multiplier */\n  csatImpactMultiplier: number;\n}\n\nexport interface RoiSummary {\n  period: { from: string; to: string };\n  /** Total estimated savings */\n  totalSavings: number;\n  /** Breakdown by category */\n  breakdown: {\n    ticketDeflection: number;\n    escalationPrevention: number;\n    timeToResolution: number;\n    churnPrevention: number;\n  };\n  /** Confidence in these estimates */\n  confidence: 'low' | 'medium' | 'high';\n  /** Methodology used */\n  methodology: string;\n}\n\n// ============================================================================\n// EXPLAINABILITY RESULT (v2 compatibility)\n// ============================================================================\n\n/**\n * @deprecated Use AnalysisResult instead\n */\nexport interface ExplainabilityResult {\n  traceId: string;\n  explainabilityId: string;\n  summary: string;\n  outcome: {\n    verdict: 'success' | 'partial_success' | 'failure';\n    confidence: number;\n    reasoning: string;\n  };\n  businessImpact: {\n    impactScore: number;\n    customerSatisfaction: number;\n    revenueRisk: string;\n  };\n  recommendations: Array<{\n    priority: string;\n    category: string;\n    action: string;\n    expectedImpact: string;\n  }>;\n  ragEvaluation?: {\n    groundedness: number;\n    faithfulness: number;\n    answerRelevance: number;\n  };\n  hallucinationReport?: {\n    detected: boolean;\n    types: string[];\n    severity: string;\n  };\n  processingTimeMs: number;\n}\n\n// ============================================================================\n// API RESPONSE TYPES\n// ============================================================================\n\nexport interface ApiResponse<T> {\n  success: boolean;\n  data?: T;\n  error?: {\n    code: string;\n    message: string;\n    details?: unknown;\n  };\n}\n\nexport interface PaginatedResponse<T> {\n  success: boolean;\n  data: {\n    items: T[];\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n  };\n}\n\nexport interface RunResponse {\n  id: string;\n  companyId: string;\n  agentId: string;\n  ticketId?: string;\n  customerAccountId?: string;\n  sessionId?: string;\n  startedAt: string;\n  endedAt?: string;\n  durationMs?: number;\n  outcome?: RunOutcome;\n  outcomeReason?: string;\n  conversationMessages: ConversationMessage[];\n  modelId?: string;\n  promptVersion?: string;\n  customerContextSnapshot?: CustomerContextSnapshot;\n  zendeskMarker?: string;\n  createdAt: string;\n  updatedAt: string;\n}\n"]}