@thinkhive/sdk 4.0.1 → 4.2.0

package/dist/api/roi-analytics.js

@@ -164,6 +164,69 @@ exports.roiAnalytics = {
         const response = await (0, client_1.apiRequest)(`/analytics/roi/correlations?${params.toString()}`, { apiVersion: 'v1' });
         return response.data.analysis;
     },
+    /**
+     * Get ROI configuration (V3)
+     */
+    async getConfig() {
+        return (0, client_1.apiRequestWithData)('/roi/config', { apiVersion: 'v3' });
+    },
+    /**
+     * Create ROI configuration (V3)
+     */
+    async createConfig(data) {
+        return (0, client_1.apiRequestWithData)('/roi/config', {
+            method: 'POST',
+            apiVersion: 'v3',
+            body: data,
+        });
+    },
+    /**
+     * Update ROI configuration (V3) - creates new version
+     */
+    async updateConfig(data) {
+        return (0, client_1.apiRequestWithData)('/roi/config', {
+            method: 'PUT',
+            apiVersion: 'v3',
+            body: data,
+        });
+    },
+    /**
+     * List ROI config versions (V3)
+     */
+    async configVersions(options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set('limit', options.limit.toString());
+        if (options?.offset)
+            params.set('offset', options.offset.toString());
+        return (0, client_1.apiRequestWithData)(`/roi/config/versions?${params.toString()}`, { apiVersion: 'v3' });
+    },
+    /**
+     * Calculate ROI using V3 configurable engine
+     */
+    async calculateV3(options) {
+        return (0, client_1.apiRequestWithData)('/roi/calculate', {
+            method: 'POST',
+            apiVersion: 'v3',
+            body: {
+                ...options,
+                startDate: new Date(options.startDate).toISOString(),
+                endDate: new Date(options.endDate).toISOString(),
+            },
+        });
+    },
+    /**
+     * Get ROI trend over time (V3)
+     */
+    async trendV3(options) {
+        const params = new URLSearchParams();
+        if (options.agentId)
+            params.set('agentId', options.agentId);
+        params.set('granularity', options.granularity);
+        params.set('startDate', new Date(options.startDate).toISOString());
+        params.set('endDate', new Date(options.endDate).toISOString());
+        return (0, client_1.apiRequestWithData)(`/roi/trend?${params.toString()}`, { apiVersion: 'v3' });
+    },
 };
 // ============================================================================
 // HELPER FUNCTIONS
@@ -201,4 +264,4 @@ function getROIQuality(totalFinancialImpact) {
         return 'moderate';
     return 'poor';
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roi-analytics.js","sourceRoot":"","sources":["../../src/api/roi-analytics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.1 - ROI Analytics API\n *\n * Business ROI & Metrics Engine for calculating financial impact\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type { ApiResponse } from '../core/types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/**\n * Industry-specific ROI configuration\n */\nexport interface IndustryConfig {\n  id: string;\n  name: string;\n  avgTransactionValue: number;\n  avgCustomerLTV: number;\n  avgSupportCost: number;\n  avgEscalationCost: number;\n  avgResolutionTime: number;\n}\n\n/**\n * Custom industry config input\n */\nexport interface CustomIndustryConfig {\n  industry?: string;\n  avgTransactionValue?: number;\n  avgCustomerLTV?: number;\n  avgSupportCost?: number;\n  avgEscalationCost?: number;\n  churnImpactMultiplier?: number;\n  avgResolutionTime?: number;\n}\n\n/**\n * ROI metrics summary\n */\nexport interface ROIMetrics {\n  roiCategory: string;\n  totalFinancialImpact: number;\n  revenueProtected: number;\n  costSavings: number;\n  efficiencyGain: number;\n}\n\n/**\n * Business impact analysis result\n */\nexport interface BusinessImpact {\n  impactScore: number;\n  revenueRisk: number;\n  brandRisk: number;\n  complianceRisk: number;\n  operationalImpact: number;\n  customerSatisfaction: number;\n  recommendations: string[];\n  roi: ROIMetrics;\n}\n\n/**\n * ROI summary for a date range\n */\nexport interface ROISummary {\n  dateRange: { start: string; end: string };\n  traceCount: number;\n  successfulInteractions: number;\n  failedInteractions: number;\n  successRate: number;\n  roi: ROIMetrics;\n  revenueProtected: number;\n  estimatedSavings: number;\n}\n\n/**\n * Daily trend data point\n */\nexport interface TrendDataPoint {\n  date: string;\n  traceCount: number;\n  successCount: number;\n  failureCount: number;\n  successRate: number;\n  avgImpactScore: number;\n}\n\n/**\n * Correlation finding\n */\nexport interface Correlation {\n  type: string;\n  strength: string;\n  coefficient: number;\n  confidence: number;\n  description: string;\n  insight: string;\n  recommendation: string;\n}\n\n/**\n * Pattern cluster\n */\nexport interface PatternCluster {\n  id: string;\n  name: string;\n  matchCount: number;\n  avgImpactScore: number;\n  avgChurnRisk: number;\n  trend: string;\n  examples: string[];\n}\n\n/**\n * Correlation analysis result\n */\nexport interface CorrelationAnalysis {\n  analysisId: string;\n  analyzedAt: string;\n  traceCount: number;\n  timeRange: { start: string; end: string };\n  overallHealthScore: number;\n  topInsights: string[];\n  recommendations: string[];\n  correlations: Correlation[];\n  patternClusters: PatternCluster[];\n}\n\n// ============================================================================\n// ROI ANALYTICS API CLIENT\n// ============================================================================\n\n/**\n * ROI Analytics API client for business impact analysis\n */\nexport const roiAnalytics = {\n  /**\n   * Get aggregated ROI summary for traces in date range\n   *\n   * @example\n   * ```typescript\n   * const summary = await roiAnalytics.summary({\n   *   startDate: '2024-01-01',\n   *   endDate: '2024-01-31',\n   * });\n   * console.log(`Revenue protected: $${summary.revenueProtected}`);\n   * ```\n   */\n  async summary(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<ROISummary> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ summary: ROISummary }>>(\n      `/analytics/roi/summary?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.summary;\n  },\n\n  /**\n   * Get ROI metrics for a specific agent\n   *\n   * @example\n   * ```typescript\n   * const agentROI = await roiAnalytics.byAgent('agent_123', {\n   *   startDate: '2024-01-01',\n   * });\n   * console.log(`Agent: ${agentROI.agent.name}`);\n   * console.log(`ROI: ${agentROI.roi.totalFinancialImpact}`);\n   * ```\n   */\n  async byAgent(\n    agentId: string,\n    options: {\n      startDate?: string | Date;\n      endDate?: string | Date;\n    } = {}\n  ): Promise<{\n    agent: { id: string; name: string; industry: string };\n    industryConfig: Partial<IndustryConfig>;\n    roi: ROIMetrics;\n    recentImpacts: Array<{\n      impactScore: number;\n      revenueRisk: number;\n      roiCategory: string;\n      totalFinancialImpact: number;\n    }>;\n  }> {\n    const params = new URLSearchParams();\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\n    return apiRequestWithData(\n      `/analytics/roi/by-agent/${agentId}?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get ROI trends over time\n   *\n   * @example\n   * ```typescript\n   * const trends = await roiAnalytics.trends({\n   *   startDate: '2024-01-01',\n   *   endDate: '2024-01-31',\n   * });\n   * for (const day of trends) {\n   *   console.log(`${day.date}: ${day.successRate}% success`);\n   * }\n   * ```\n   */\n  async trends(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<TrendDataPoint[]> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ trends: TrendDataPoint[] }>>(\n      `/analytics/roi/trends?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.trends;\n  },\n\n  /**\n   * Calculate ROI for a trace or provided message data\n   *\n   * @example\n   * ```typescript\n   * // Calculate for existing trace\n   * const impact = await roiAnalytics.calculate({\n   *   traceId: 'trace_abc123',\n   * });\n   *\n   * // Calculate for new data with custom config\n   * const impact = await roiAnalytics.calculate({\n   *   userMessage: 'Help me cancel my subscription',\n   *   agentResponse: 'I can help with that...',\n   *   industryConfig: { industry: 'saas', avgCustomerLTV: 10000 },\n   * });\n   * ```\n   */\n  async calculate(options: {\n    traceId?: string;\n    userMessage?: string;\n    agentResponse?: string;\n    industryConfig?: CustomIndustryConfig;\n  }): Promise<BusinessImpact> {\n    const response = await apiRequest<ApiResponse<{ impact: BusinessImpact }>>(\n      '/analytics/roi/calculate',\n      {\n        method: 'POST',\n        body: options,\n        apiVersion: 'v1',\n      }\n    );\n    return response.data!.impact;\n  },\n\n  /**\n   * Get available industry configurations\n   *\n   * @example\n   * ```typescript\n   * const industries = await roiAnalytics.industries();\n   * for (const config of industries) {\n   *   console.log(`${config.name}: $${config.avgCustomerLTV} LTV`);\n   * }\n   * ```\n   */\n  async industries(): Promise<IndustryConfig[]> {\n    const response = await apiRequest<ApiResponse<{ industries: IndustryConfig[] }>>(\n      '/analytics/roi/industries',\n      { apiVersion: 'v1' }\n    );\n    return response.data!.industries;\n  },\n\n  /**\n   * Get correlation analysis for traces\n   *\n   * @example\n   * ```typescript\n   * const analysis = await roiAnalytics.correlations({\n   *   startDate: '2024-01-01',\n   *   agentId: 'agent_123',\n   * });\n   * console.log(`Health score: ${analysis.overallHealthScore}`);\n   * for (const insight of analysis.topInsights) {\n   *   console.log(`- ${insight}`);\n   * }\n   * ```\n   */\n  async correlations(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<CorrelationAnalysis> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ analysis: CorrelationAnalysis }>>(\n      `/analytics/roi/correlations?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.analysis;\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate estimated revenue at risk\n */\nexport function calculateRevenueAtRisk(\n  failureRate: number,\n  avgTransactionValue: number,\n  totalInteractions: number\n): number {\n  return failureRate * avgTransactionValue * totalInteractions;\n}\n\n/**\n * Calculate estimated savings from automation\n */\nexport function calculateAutomationSavings(\n  successfulInteractions: number,\n  avgSupportCost: number\n): number {\n  return successfulInteractions * avgSupportCost;\n}\n\n/**\n * Format currency for display\n */\nexport function formatCurrency(amount: number, currency = 'USD'): string {\n  return new Intl.NumberFormat('en-US', {\n    style: 'currency',\n    currency,\n  }).format(amount);\n}\n\n/**\n * Get ROI quality label\n */\nexport function getROIQuality(\n  totalFinancialImpact: number\n): 'excellent' | 'good' | 'moderate' | 'poor' {\n  if (totalFinancialImpact > 100000) return 'excellent';\n  if (totalFinancialImpact > 50000) return 'good';\n  if (totalFinancialImpact > 10000) return 'moderate';\n  return 'poor';\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"roi-analytics.js","sourceRoot":"","sources":["../../src/api/roi-analytics.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.1 - ROI Analytics API\n *\n * Business ROI & Metrics Engine for calculating financial impact\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type { ApiResponse } from '../core/types';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/**\n * Industry-specific ROI configuration\n */\nexport interface IndustryConfig {\n  id: string;\n  name: string;\n  avgTransactionValue: number;\n  avgCustomerLTV: number;\n  avgSupportCost: number;\n  avgEscalationCost: number;\n  avgResolutionTime: number;\n}\n\n/**\n * Custom industry config input\n */\nexport interface CustomIndustryConfig {\n  industry?: string;\n  avgTransactionValue?: number;\n  avgCustomerLTV?: number;\n  avgSupportCost?: number;\n  avgEscalationCost?: number;\n  churnImpactMultiplier?: number;\n  avgResolutionTime?: number;\n}\n\n/**\n * ROI metrics summary\n */\nexport interface ROIMetrics {\n  roiCategory: string;\n  totalFinancialImpact: number;\n  revenueProtected: number;\n  costSavings: number;\n  efficiencyGain: number;\n}\n\n/**\n * Business impact analysis result\n */\nexport interface BusinessImpact {\n  impactScore: number;\n  revenueRisk: number;\n  brandRisk: number;\n  complianceRisk: number;\n  operationalImpact: number;\n  customerSatisfaction: number;\n  recommendations: string[];\n  roi: ROIMetrics;\n}\n\n/**\n * ROI summary for a date range\n */\nexport interface ROISummary {\n  dateRange: { start: string; end: string };\n  traceCount: number;\n  successfulInteractions: number;\n  failedInteractions: number;\n  successRate: number;\n  roi: ROIMetrics;\n  revenueProtected: number;\n  estimatedSavings: number;\n}\n\n/**\n * Daily trend data point\n */\nexport interface TrendDataPoint {\n  date: string;\n  traceCount: number;\n  successCount: number;\n  failureCount: number;\n  successRate: number;\n  avgImpactScore: number;\n}\n\n/**\n * Correlation finding\n */\nexport interface Correlation {\n  type: string;\n  strength: string;\n  coefficient: number;\n  confidence: number;\n  description: string;\n  insight: string;\n  recommendation: string;\n}\n\n/**\n * Pattern cluster\n */\nexport interface PatternCluster {\n  id: string;\n  name: string;\n  matchCount: number;\n  avgImpactScore: number;\n  avgChurnRisk: number;\n  trend: string;\n  examples: string[];\n}\n\n/**\n * Correlation analysis result\n */\nexport interface CorrelationAnalysis {\n  analysisId: string;\n  analyzedAt: string;\n  traceCount: number;\n  timeRange: { start: string; end: string };\n  overallHealthScore: number;\n  topInsights: string[];\n  recommendations: string[];\n  correlations: Correlation[];\n  patternClusters: PatternCluster[];\n}\n\n// ============================================================================\n// ROI ANALYTICS API CLIENT\n// ============================================================================\n\n/**\n * ROI Analytics API client for business impact analysis\n */\nexport const roiAnalytics = {\n  /**\n   * Get aggregated ROI summary for traces in date range\n   *\n   * @example\n   * ```typescript\n   * const summary = await roiAnalytics.summary({\n   *   startDate: '2024-01-01',\n   *   endDate: '2024-01-31',\n   * });\n   * console.log(`Revenue protected: $${summary.revenueProtected}`);\n   * ```\n   */\n  async summary(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<ROISummary> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ summary: ROISummary }>>(\n      `/analytics/roi/summary?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.summary;\n  },\n\n  /**\n   * Get ROI metrics for a specific agent\n   *\n   * @example\n   * ```typescript\n   * const agentROI = await roiAnalytics.byAgent('agent_123', {\n   *   startDate: '2024-01-01',\n   * });\n   * console.log(`Agent: ${agentROI.agent.name}`);\n   * console.log(`ROI: ${agentROI.roi.totalFinancialImpact}`);\n   * ```\n   */\n  async byAgent(\n    agentId: string,\n    options: {\n      startDate?: string | Date;\n      endDate?: string | Date;\n    } = {}\n  ): Promise<{\n    agent: { id: string; name: string; industry: string };\n    industryConfig: Partial<IndustryConfig>;\n    roi: ROIMetrics;\n    recentImpacts: Array<{\n      impactScore: number;\n      revenueRisk: number;\n      roiCategory: string;\n      totalFinancialImpact: number;\n    }>;\n  }> {\n    const params = new URLSearchParams();\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\n    return apiRequestWithData(\n      `/analytics/roi/by-agent/${agentId}?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get ROI trends over time\n   *\n   * @example\n   * ```typescript\n   * const trends = await roiAnalytics.trends({\n   *   startDate: '2024-01-01',\n   *   endDate: '2024-01-31',\n   * });\n   * for (const day of trends) {\n   *   console.log(`${day.date}: ${day.successRate}% success`);\n   * }\n   * ```\n   */\n  async trends(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<TrendDataPoint[]> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ trends: TrendDataPoint[] }>>(\n      `/analytics/roi/trends?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.trends;\n  },\n\n  /**\n   * Calculate ROI for a trace or provided message data\n   *\n   * @example\n   * ```typescript\n   * // Calculate for existing trace\n   * const impact = await roiAnalytics.calculate({\n   *   traceId: 'trace_abc123',\n   * });\n   *\n   * // Calculate for new data with custom config\n   * const impact = await roiAnalytics.calculate({\n   *   userMessage: 'Help me cancel my subscription',\n   *   agentResponse: 'I can help with that...',\n   *   industryConfig: { industry: 'saas', avgCustomerLTV: 10000 },\n   * });\n   * ```\n   */\n  async calculate(options: {\n    traceId?: string;\n    userMessage?: string;\n    agentResponse?: string;\n    industryConfig?: CustomIndustryConfig;\n  }): Promise<BusinessImpact> {\n    const response = await apiRequest<ApiResponse<{ impact: BusinessImpact }>>(\n      '/analytics/roi/calculate',\n      {\n        method: 'POST',\n        body: options,\n        apiVersion: 'v1',\n      }\n    );\n    return response.data!.impact;\n  },\n\n  /**\n   * Get available industry configurations\n   *\n   * @example\n   * ```typescript\n   * const industries = await roiAnalytics.industries();\n   * for (const config of industries) {\n   *   console.log(`${config.name}: $${config.avgCustomerLTV} LTV`);\n   * }\n   * ```\n   */\n  async industries(): Promise<IndustryConfig[]> {\n    const response = await apiRequest<ApiResponse<{ industries: IndustryConfig[] }>>(\n      '/analytics/roi/industries',\n      { apiVersion: 'v1' }\n    );\n    return response.data!.industries;\n  },\n\n  /**\n   * Get correlation analysis for traces\n   *\n   * @example\n   * ```typescript\n   * const analysis = await roiAnalytics.correlations({\n   *   startDate: '2024-01-01',\n   *   agentId: 'agent_123',\n   * });\n   * console.log(`Health score: ${analysis.overallHealthScore}`);\n   * for (const insight of analysis.topInsights) {\n   *   console.log(`- ${insight}`);\n   * }\n   * ```\n   */\n  async correlations(options: {\n    startDate?: string | Date;\n    endDate?: string | Date;\n    agentId?: string;\n  } = {}): Promise<CorrelationAnalysis> {\n    const params = new URLSearchParams();\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.agentId) {\n      params.set('agentId', options.agentId);\n    }\n\n    const response = await apiRequest<ApiResponse<{ analysis: CorrelationAnalysis }>>(\n      `/analytics/roi/correlations?${params.toString()}`,\n      { apiVersion: 'v1' }\n    );\n    return response.data!.analysis;\n  },\n\n  /**\n   * Get ROI configuration (V3)\n   */\n  async getConfig(): Promise<{\n    id: string;\n    companyId: string;\n    version: number;\n    isActive: boolean;\n    costConfig: Record<string, unknown>;\n    deflectionConfig: Record<string, unknown>;\n    resolutionConfig: Record<string, unknown>;\n    attributionConfig: Record<string, unknown>;\n    slaConfig: Record<string, unknown>;\n    displayConfig: Record<string, unknown>;\n    createdAt: string;\n    updatedAt: string;\n  }> {\n    return apiRequestWithData('/roi/config', { apiVersion: 'v3' });\n  },\n\n  /**\n   * Create ROI configuration (V3)\n   */\n  async createConfig(data: {\n    costConfig?: Record<string, unknown>;\n    deflectionConfig?: Record<string, unknown>;\n    resolutionConfig?: Record<string, unknown>;\n    attributionConfig?: Record<string, unknown>;\n    slaConfig?: Record<string, unknown>;\n    displayConfig?: Record<string, unknown>;\n  }): Promise<{\n    id: string;\n    companyId: string;\n    version: number;\n    isActive: boolean;\n    costConfig: Record<string, unknown>;\n    deflectionConfig: Record<string, unknown>;\n    resolutionConfig: Record<string, unknown>;\n    attributionConfig: Record<string, unknown>;\n    slaConfig: Record<string, unknown>;\n    displayConfig: Record<string, unknown>;\n    createdAt: string;\n    updatedAt: string;\n  }> {\n    return apiRequestWithData('/roi/config', {\n      method: 'POST',\n      apiVersion: 'v3',\n      body: data,\n    });\n  },\n\n  /**\n   * Update ROI configuration (V3) - creates new version\n   */\n  async updateConfig(data: {\n    costConfig?: Record<string, unknown>;\n    deflectionConfig?: Record<string, unknown>;\n    resolutionConfig?: Record<string, unknown>;\n    attributionConfig?: Record<string, unknown>;\n    slaConfig?: Record<string, unknown>;\n    displayConfig?: Record<string, unknown>;\n  }): Promise<{\n    id: string;\n    companyId: string;\n    version: number;\n    isActive: boolean;\n    costConfig: Record<string, unknown>;\n    deflectionConfig: Record<string, unknown>;\n    resolutionConfig: Record<string, unknown>;\n    attributionConfig: Record<string, unknown>;\n    slaConfig: Record<string, unknown>;\n    displayConfig: Record<string, unknown>;\n    createdAt: string;\n    updatedAt: string;\n  }> {\n    return apiRequestWithData('/roi/config', {\n      method: 'PUT',\n      apiVersion: 'v3',\n      body: data,\n    });\n  },\n\n  /**\n   * List ROI config versions (V3)\n   */\n  async configVersions(options?: { limit?: number; offset?: number }): Promise<{\n    data: Record<string, unknown>[];\n    pagination: { limit: number; offset: number; hasMore: boolean };\n  }> {\n    const params = new URLSearchParams();\n    if (options?.limit) params.set('limit', options.limit.toString());\n    if (options?.offset) params.set('offset', options.offset.toString());\n    return apiRequestWithData(`/roi/config/versions?${params.toString()}`, { apiVersion: 'v3' });\n  },\n\n  /**\n   * Calculate ROI using V3 configurable engine\n   */\n  async calculateV3(options: {\n    agentId?: string;\n    startDate: string | Date;\n    endDate: string | Date;\n    configurationVersion?: number;\n    includeBreakdown?: boolean;\n    includeConfidenceIntervals?: boolean;\n  }): Promise<Record<string, unknown>> {\n    return apiRequestWithData('/roi/calculate', {\n      method: 'POST',\n      apiVersion: 'v3',\n      body: {\n        ...options,\n        startDate: new Date(options.startDate).toISOString(),\n        endDate: new Date(options.endDate).toISOString(),\n      },\n    });\n  },\n\n  /**\n   * Get ROI trend over time (V3)\n   */\n  async trendV3(options: {\n    agentId?: string;\n    granularity: 'day' | 'week' | 'month';\n    startDate: string | Date;\n    endDate: string | Date;\n  }): Promise<Record<string, unknown>> {\n    const params = new URLSearchParams();\n    if (options.agentId) params.set('agentId', options.agentId);\n    params.set('granularity', options.granularity);\n    params.set('startDate', new Date(options.startDate).toISOString());\n    params.set('endDate', new Date(options.endDate).toISOString());\n    return apiRequestWithData(`/roi/trend?${params.toString()}`, { apiVersion: 'v3' });\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Calculate estimated revenue at risk\n */\nexport function calculateRevenueAtRisk(\n  failureRate: number,\n  avgTransactionValue: number,\n  totalInteractions: number\n): number {\n  return failureRate * avgTransactionValue * totalInteractions;\n}\n\n/**\n * Calculate estimated savings from automation\n */\nexport function calculateAutomationSavings(\n  successfulInteractions: number,\n  avgSupportCost: number\n): number {\n  return successfulInteractions * avgSupportCost;\n}\n\n/**\n * Format currency for display\n */\nexport function formatCurrency(amount: number, currency = 'USD'): string {\n  return new Intl.NumberFormat('en-US', {\n    style: 'currency',\n    currency,\n  }).format(amount);\n}\n\n/**\n * Get ROI quality label\n */\nexport function getROIQuality(\n  totalFinancialImpact: number\n): 'excellent' | 'good' | 'moderate' | 'poor' {\n  if (totalFinancialImpact > 100000) return 'excellent';\n  if (totalFinancialImpact > 50000) return 'good';\n  if (totalFinancialImpact > 10000) return 'moderate';\n  return 'poor';\n}\n"]}

package/dist/api/sessions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * ThinkHive SDK - Sessions API
+ *
+ * Trace session grouping for multi-turn conversation tracking
+ */
+/** Options for listing sessions */
+export interface ListSessionsOptions {
+    limit?: number;
+    offset?: number;
+}
+/** A trace session */
+export interface Session {
+    sessionId: string;
+    agentId: string;
+    traceCount: number;
+    firstTraceAt: string;
+    lastTraceAt: string;
+    metadata?: Record<string, unknown>;
+}
+/** A trace within a session */
+export interface SessionTrace {
+    id: string;
+    agentId: string;
+    sessionId: string;
+    input?: unknown;
+    output?: unknown;
+    status: string;
+    createdAt: string;
+    [key: string]: unknown;
+}
+/**
+ * Sessions API client for trace session grouping
+ */
+export declare const sessions: {
+    /**
+     * List sessions for an agent
+     *
+     * @param agentId - The agent ID
+     * @param opts - Pagination options
+     * @returns List of sessions
+     */
+    list(agentId: string, opts?: ListSessionsOptions): Promise<{
+        sessions: Session[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get traces for a specific session
+     *
+     * @param sessionId - The session ID
+     * @param agentId - The agent ID
+     * @returns List of traces in the session
+     */
+    getTraces(sessionId: string, agentId: string): Promise<SessionTrace[]>;
+};
+export { sessions as default };

package/dist/api/sessions.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * ThinkHive SDK - Sessions API
+ *
+ * Trace session grouping for multi-turn conversation tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.sessions = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SESSIONS API CLIENT
+// ============================================================================
+/**
+ * Sessions API client for trace session grouping
+ */
+exports.sessions = {
+    /**
+     * List sessions for an agent
+     *
+     * @param agentId - The agent ID
+     * @param opts - Pagination options
+     * @returns List of sessions
+     */
+    async list(agentId, opts) {
+        const params = new URLSearchParams({ agentId });
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        return (0, client_1.apiRequestWithData)(`/traces/sessions?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get traces for a specific session
+     *
+     * @param sessionId - The session ID
+     * @param agentId - The agent ID
+     * @returns List of traces in the session
+     */
+    async getTraces(sessionId, agentId) {
+        const params = new URLSearchParams({ agentId, sessionId });
+        return (0, client_1.apiRequestWithData)(`/traces?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+};
+exports.default = exports.sessions;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/shadow-tests.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ThinkHive SDK - Shadow Tests API
+ *
+ * Shadow test execution for validating proposed fixes
+ */
+/** Data for creating a shadow test */
+export interface CreateShadowTestData {
+    fixId: string;
+    agentId: string;
+    testName: string;
+    inputData: unknown;
+    expectedOutput: unknown;
+}
+/** Data for updating a shadow test */
+export interface UpdateShadowTestData {
+    testName?: string;
+    status?: string;
+    actualOutput?: unknown;
+    passed?: boolean;
+    metadata?: Record<string, unknown>;
+}
+/** A shadow test record */
+export interface ShadowTest {
+    id: string;
+    fixId: string;
+    agentId: string;
+    testName: string;
+    inputData: unknown;
+    expectedOutput: unknown;
+    actualOutput?: unknown;
+    status: string;
+    passed?: boolean;
+    createdAt: string;
+    completedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Shadow tests API client for managing shadow test execution
+ */
+export declare const shadowTests: {
+    /**
+     * List shadow tests for an agent
+     *
+     * @param agentId - The agent ID
+     * @returns List of shadow tests
+     */
+    list(agentId: string): Promise<ShadowTest[]>;
+    /**
+     * Get a shadow test by ID
+     *
+     * @param id - The shadow test ID
+     * @returns The shadow test details
+     */
+    get(id: string): Promise<ShadowTest>;
+    /**
+     * Get shadow tests for a specific fix
+     *
+     * @param fixId - The fix ID
+     * @returns List of shadow tests for the fix
+     */
+    getByFix(fixId: string): Promise<ShadowTest[]>;
+    /**
+     * Create a new shadow test
+     *
+     * @param data - Shadow test configuration
+     * @returns The created shadow test
+     */
+    create(data: CreateShadowTestData): Promise<ShadowTest>;
+    /**
+     * Update a shadow test
+     *
+     * @param id - The shadow test ID to update
+     * @param data - Fields to update
+     * @returns The updated shadow test
+     */
+    update(id: string, data: UpdateShadowTestData): Promise<ShadowTest>;
+};
+export { shadowTests as default };

package/dist/api/shadow-tests.js

@@ -0,0 +1,80 @@
+"use strict";
+/**
+ * ThinkHive SDK - Shadow Tests API
+ *
+ * Shadow test execution for validating proposed fixes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.shadowTests = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SHADOW TESTS API CLIENT
+// ============================================================================
+/**
+ * Shadow tests API client for managing shadow test execution
+ */
+exports.shadowTests = {
+    /**
+     * List shadow tests for an agent
+     *
+     * @param agentId - The agent ID
+     * @returns List of shadow tests
+     */
+    async list(agentId) {
+        const params = new URLSearchParams({ agentId });
+        return (0, client_1.apiRequestWithData)(`/shadow-tests?${params}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get a shadow test by ID
+     *
+     * @param id - The shadow test ID
+     * @returns The shadow test details
+     */
+    async get(id) {
+        return (0, client_1.apiRequestWithData)(`/shadow-tests/${id}`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Get shadow tests for a specific fix
+     *
+     * @param fixId - The fix ID
+     * @returns List of shadow tests for the fix
+     */
+    async getByFix(fixId) {
+        return (0, client_1.apiRequestWithData)(`/fixes/${fixId}/shadow-tests`, {
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Create a new shadow test
+     *
+     * @param data - Shadow test configuration
+     * @returns The created shadow test
+     */
+    async create(data) {
+        return (0, client_1.apiRequestWithData)('/shadow-tests', {
+            method: 'POST',
+            body: data,
+            apiVersion: 'none',
+        });
+    },
+    /**
+     * Update a shadow test
+     *
+     * @param id - The shadow test ID to update
+     * @param data - Fields to update
+     * @returns The updated shadow test
+     */
+    async update(id, data) {
+        return (0, client_1.apiRequestWithData)(`/shadow-tests/${id}`, {
+            method: 'PATCH',
+            body: data,
+            apiVersion: 'none',
+        });
+    },
+};
+exports.default = exports.shadowTests;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/api/signals.d.ts

@@ -0,0 +1,177 @@
+/**
+ * ThinkHive SDK - Signals API
+ *
+ * Behavioral signal management for detecting patterns in agent interactions
+ */
+/** Signal detection configuration */
+export interface DetectionConfig {
+    type: string;
+    threshold?: number;
+    pattern?: string;
+    [key: string]: unknown;
+}
+/** Options for creating a signal */
+export interface CreateSignalOptions {
+    description?: string;
+    isEnabled?: boolean;
+    severity?: string;
+}
+/** Options for updating a signal */
+export interface UpdateSignalOptions {
+    name?: string;
+    group?: string;
+    description?: string;
+    detectionConfig?: DetectionConfig;
+    isEnabled?: boolean;
+    severity?: string;
+}
+/** Options for listing signals */
+export interface ListSignalsOptions {
+    group?: string;
+    source?: string;
+    isEnabled?: boolean;
+}
+/** Options for getting signal stats */
+export interface SignalStatsOptions {
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+}
+/** Options for getting signal trends */
+export interface SignalTrendsOptions {
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+    granularity?: 'hour' | 'day' | 'week' | 'month';
+}
+/** Options for getting signal traces */
+export interface SignalTracesOptions {
+    limit?: number;
+    offset?: number;
+    startDate?: string;
+    endDate?: string;
+    agentId?: string;
+}
+/** Options for getting signal events */
+export interface SignalEventsOptions {
+    limit?: number;
+    offset?: number;
+}
+/** A behavioral signal definition */
+export interface Signal {
+    id: string;
+    name: string;
+    group: string;
+    description?: string;
+    detectionConfig: DetectionConfig;
+    isEnabled: boolean;
+    severity?: string;
+    source?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Signal statistics */
+export interface SignalStats {
+    signalId: string;
+    name: string;
+    eventCount: number;
+    traceCount: number;
+    lastTriggeredAt?: string;
+}
+/** Signal trend data point */
+export interface SignalTrendPoint {
+    period: string;
+    eventCount: number;
+    traceCount: number;
+}
+/** A signal event occurrence */
+export interface SignalEvent {
+    id: string;
+    signalId: string;
+    traceId: string;
+    detectedAt: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Signals API client for managing behavioral signal detection
+ */
+export declare const signals: {
+    /**
+     * List all signals with optional filters
+     *
+     * @param opts - Filter options for group, source, or enabled status
+     * @returns List of signals
+     */
+    list(opts?: ListSignalsOptions): Promise<Signal[]>;
+    /**
+     * Create a new behavioral signal
+     *
+     * @param name - Signal name
+     * @param group - Signal group/category
+     * @param detectionConfig - Detection configuration
+     * @param opts - Additional signal options
+     * @returns The created signal
+     */
+    create(name: string, group: string, detectionConfig: DetectionConfig, opts?: CreateSignalOptions): Promise<Signal>;
+    /**
+     * Update an existing signal
+     *
+     * @param id - Signal ID to update
+     * @param opts - Fields to update
+     * @returns The updated signal
+     */
+    update(id: string, opts: UpdateSignalOptions): Promise<Signal>;
+    /**
+     * Delete a signal
+     *
+     * @param id - Signal ID to delete
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Seed default signal definitions
+     *
+     * @returns List of seeded signals
+     */
+    seedDefaults(): Promise<Signal[]>;
+    /**
+     * Get signal statistics
+     *
+     * @param opts - Date range and agent filter options
+     * @returns Signal statistics
+     */
+    getStats(opts?: SignalStatsOptions): Promise<SignalStats[]>;
+    /**
+     * Get signal trend data over time
+     *
+     * @param opts - Date range, agent, and granularity options
+     * @returns Signal trend data points
+     */
+    getTrends(opts?: SignalTrendsOptions): Promise<SignalTrendPoint[]>;
+    /**
+     * Get traces that triggered a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination and filter options
+     * @returns Traces associated with the signal
+     */
+    getTraces(id: string, opts?: SignalTracesOptions): Promise<{
+        traces: any[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Get events for a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination options
+     * @returns Signal events
+     */
+    getEvents(id: string, opts?: SignalEventsOptions): Promise<{
+        events: SignalEvent[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+};
+export { signals as default };