@thinkhive/sdk 3.1.0 → 3.3.0

package/dist/api/transcript-patterns.d.ts

@@ -0,0 +1,204 @@
+/**
+ * ThinkHive SDK v3.0 - Transcript Patterns API
+ *
+ * API for transcript pattern detection and analysis
+ */
+export type PatternCategory = 'frustration' | 'confusion' | 'success' | 'failure' | 'escalation' | 'pii_exposure' | 'hallucination' | 'custom';
+export type PatternOutcome = 'success' | 'failure' | 'escalation' | 'neutral';
+export type PatternSeverity = 'info' | 'warning' | 'critical';
+export type DetectionType = 'sequence' | 'keywords' | 'regex';
+export interface PatternMatch {
+    patternId: string;
+    patternName: string;
+    category: PatternCategory;
+    matchedText?: string;
+    position?: {
+        start: number;
+        end: number;
+    };
+    confidence: number;
+    severity: PatternSeverity;
+}
+export interface PatternInsight {
+    type: string;
+    message: string;
+    severity: PatternSeverity;
+    recommendation?: string;
+}
+export interface AnalysisResult {
+    traceId: string;
+    sessionId?: string;
+    patternsMatched: number;
+    riskScore: number;
+    predictedOutcome?: PatternOutcome;
+    predictionConfidence?: number;
+    matches: PatternMatch[];
+    insights: PatternInsight[];
+    sentimentScores?: {
+        overall: number;
+        byTurn?: Array<{
+            turn: number;
+            sentiment: number;
+            confidence: number;
+        }>;
+    };
+}
+export interface BulkAnalysisResult {
+    results: Array<AnalysisResult & {
+        error?: string;
+    }>;
+    summary: {
+        tracesAnalyzed: number;
+        totalMatches: number;
+        tracesWithMatches: number;
+    };
+}
+export interface PatternCategoryInfo {
+    id: PatternCategory;
+    name: string;
+    description: string;
+    indicators: string[];
+}
+export interface BuiltInPattern {
+    id: string;
+    name: string;
+    category: PatternCategory;
+    detectionType: DetectionType;
+    description: string;
+}
+/**
+ * Transcript Patterns API client for pattern detection and analysis
+ */
+export declare const transcriptPatterns: {
+    /**
+     * Analyze a trace for patterns
+     *
+     * @example
+     * ```typescript
+     * const result = await transcriptPatterns.analyze('trace_123');
+     * console.log(`Found ${result.patternsMatched} patterns`);
+     * console.log(`Risk score: ${result.riskScore}`);
+     * ```
+     */
+    analyze(traceId: string): Promise<AnalysisResult>;
+    /**
+     * Analyze multiple traces for patterns
+     *
+     * @example
+     * ```typescript
+     * const { results, summary } = await transcriptPatterns.bulkAnalyze([
+     *   'trace_1', 'trace_2', 'trace_3'
+     * ]);
+     * console.log(`${summary.tracesWithMatches} traces have patterns`);
+     * ```
+     */
+    bulkAnalyze(traceIds: string[]): Promise<BulkAnalysisResult>;
+    /**
+     * Get available pattern categories with descriptions
+     *
+     * @example
+     * ```typescript
+     * const categories = await transcriptPatterns.getCategories();
+     * for (const category of categories) {
+     *   console.log(`${category.name}: ${category.description}`);
+     * }
+     * ```
+     */
+    getCategories(): Promise<PatternCategoryInfo[]>;
+    /**
+     * Get built-in patterns
+     *
+     * @example
+     * ```typescript
+     * const patterns = await transcriptPatterns.getBuiltInPatterns();
+     * const frustrationPatterns = patterns.filter(p => p.category === 'frustration');
+     * ```
+     */
+    getBuiltInPatterns(): Promise<BuiltInPattern[]>;
+};
+/**
+ * Check if analysis result indicates high risk
+ *
+ * @param result - Analysis result to check
+ * @param threshold - Risk score threshold (default 70)
+ * @returns Whether the result indicates high risk
+ */
+export declare function isHighRisk(result: AnalysisResult, threshold?: number): boolean;
+/**
+ * Get matches by category
+ *
+ * @param result - Analysis result
+ * @param category - Pattern category to filter by
+ * @returns Filtered pattern matches
+ */
+export declare function getMatchesByCategory(result: AnalysisResult, category: PatternCategory): PatternMatch[];
+/**
+ * Get critical insights from analysis
+ *
+ * @param result - Analysis result
+ * @returns Critical severity insights
+ */
+export declare function getCriticalInsights(result: AnalysisResult): PatternInsight[];
+/**
+ * Check if analysis detected PII
+ *
+ * @param result - Analysis result
+ * @returns Whether PII was detected
+ */
+export declare function hasPiiExposure(result: AnalysisResult): boolean;
+/**
+ * Check if analysis detected frustration
+ *
+ * @param result - Analysis result
+ * @returns Whether frustration was detected
+ */
+export declare function hasFrustrationSignals(result: AnalysisResult): boolean;
+/**
+ * Check if analysis detected escalation request
+ *
+ * @param result - Analysis result
+ * @returns Whether escalation was requested
+ */
+export declare function hasEscalationRequest(result: AnalysisResult): boolean;
+/**
+ * Calculate category distribution
+ *
+ * @param result - Analysis result
+ * @returns Object with counts per category
+ */
+export declare function getCategoryDistribution(result: AnalysisResult): Record<PatternCategory, number>;
+/**
+ * Get actionable recommendations from insights
+ *
+ * @param result - Analysis result
+ * @returns Array of recommendation strings
+ */
+export declare function getRecommendations(result: AnalysisResult): string[];
+/**
+ * Calculate overall sentiment from analysis
+ *
+ * @param result - Analysis result
+ * @returns Sentiment score (-1 to 1) or null if not available
+ */
+export declare function getOverallSentiment(result: AnalysisResult): number | null;
+/**
+ * Determine if conversation needs attention based on patterns
+ *
+ * @param result - Analysis result
+ * @returns Whether the conversation needs attention
+ */
+export declare function needsAttention(result: AnalysisResult): boolean;
+/**
+ * Get severity level as numeric value
+ *
+ * @param severity - Pattern severity
+ * @returns Numeric severity (1-3)
+ */
+export declare function getSeverityLevel(severity: PatternSeverity): number;
+/**
+ * Sort matches by severity (critical first)
+ *
+ * @param matches - Pattern matches to sort
+ * @returns Sorted matches
+ */
+export declare function sortMatchesBySeverity(matches: PatternMatch[]): PatternMatch[];

package/dist/api/transcript-patterns.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Transcript Patterns API
+ *
+ * API for transcript pattern detection and analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcriptPatterns = void 0;
+exports.isHighRisk = isHighRisk;
+exports.getMatchesByCategory = getMatchesByCategory;
+exports.getCriticalInsights = getCriticalInsights;
+exports.hasPiiExposure = hasPiiExposure;
+exports.hasFrustrationSignals = hasFrustrationSignals;
+exports.hasEscalationRequest = hasEscalationRequest;
+exports.getCategoryDistribution = getCategoryDistribution;
+exports.getRecommendations = getRecommendations;
+exports.getOverallSentiment = getOverallSentiment;
+exports.needsAttention = needsAttention;
+exports.getSeverityLevel = getSeverityLevel;
+exports.sortMatchesBySeverity = sortMatchesBySeverity;
+const client_1 = require("../core/client");
+// ============================================================================
+// TRANSCRIPT PATTERNS API CLIENT
+// ============================================================================
+/**
+ * Transcript Patterns API client for pattern detection and analysis
+ */
+exports.transcriptPatterns = {
+    /**
+     * Analyze a trace for patterns
+     *
+     * @example
+     * ```typescript
+     * const result = await transcriptPatterns.analyze('trace_123');
+     * console.log(`Found ${result.patternsMatched} patterns`);
+     * console.log(`Risk score: ${result.riskScore}`);
+     * ```
+     */
+    async analyze(traceId) {
+        return (0, client_1.apiRequestWithData)('/transcript-patterns/analyze', {
+            method: 'POST',
+            body: { traceId },
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Analyze multiple traces for patterns
+     *
+     * @example
+     * ```typescript
+     * const { results, summary } = await transcriptPatterns.bulkAnalyze([
+     *   'trace_1', 'trace_2', 'trace_3'
+     * ]);
+     * console.log(`${summary.tracesWithMatches} traces have patterns`);
+     * ```
+     */
+    async bulkAnalyze(traceIds) {
+        return (0, client_1.apiRequestWithData)('/transcript-patterns/bulk-analyze', {
+            method: 'POST',
+            body: { traceIds },
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get available pattern categories with descriptions
+     *
+     * @example
+     * ```typescript
+     * const categories = await transcriptPatterns.getCategories();
+     * for (const category of categories) {
+     *   console.log(`${category.name}: ${category.description}`);
+     * }
+     * ```
+     */
+    async getCategories() {
+        return (0, client_1.apiRequestWithData)('/transcript-patterns/categories', { apiVersion: 'v1' });
+    },
+    /**
+     * Get built-in patterns
+     *
+     * @example
+     * ```typescript
+     * const patterns = await transcriptPatterns.getBuiltInPatterns();
+     * const frustrationPatterns = patterns.filter(p => p.category === 'frustration');
+     * ```
+     */
+    async getBuiltInPatterns() {
+        return (0, client_1.apiRequestWithData)('/transcript-patterns/built-in', { apiVersion: 'v1' });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if analysis result indicates high risk
+ *
+ * @param result - Analysis result to check
+ * @param threshold - Risk score threshold (default 70)
+ * @returns Whether the result indicates high risk
+ */
+function isHighRisk(result, threshold = 70) {
+    return result.riskScore >= threshold;
+}
+/**
+ * Get matches by category
+ *
+ * @param result - Analysis result
+ * @param category - Pattern category to filter by
+ * @returns Filtered pattern matches
+ */
+function getMatchesByCategory(result, category) {
+    return result.matches.filter(m => m.category === category);
+}
+/**
+ * Get critical insights from analysis
+ *
+ * @param result - Analysis result
+ * @returns Critical severity insights
+ */
+function getCriticalInsights(result) {
+    return result.insights.filter(i => i.severity === 'critical');
+}
+/**
+ * Check if analysis detected PII
+ *
+ * @param result - Analysis result
+ * @returns Whether PII was detected
+ */
+function hasPiiExposure(result) {
+    return result.matches.some(m => m.category === 'pii_exposure');
+}
+/**
+ * Check if analysis detected frustration
+ *
+ * @param result - Analysis result
+ * @returns Whether frustration was detected
+ */
+function hasFrustrationSignals(result) {
+    return result.matches.some(m => m.category === 'frustration');
+}
+/**
+ * Check if analysis detected escalation request
+ *
+ * @param result - Analysis result
+ * @returns Whether escalation was requested
+ */
+function hasEscalationRequest(result) {
+    return result.matches.some(m => m.category === 'escalation');
+}
+/**
+ * Calculate category distribution
+ *
+ * @param result - Analysis result
+ * @returns Object with counts per category
+ */
+function getCategoryDistribution(result) {
+    const distribution = {
+        frustration: 0,
+        confusion: 0,
+        success: 0,
+        failure: 0,
+        escalation: 0,
+        pii_exposure: 0,
+        hallucination: 0,
+        custom: 0,
+    };
+    for (const match of result.matches) {
+        distribution[match.category]++;
+    }
+    return distribution;
+}
+/**
+ * Get actionable recommendations from insights
+ *
+ * @param result - Analysis result
+ * @returns Array of recommendation strings
+ */
+function getRecommendations(result) {
+    return result.insights
+        .filter(i => i.recommendation)
+        .map(i => i.recommendation);
+}
+/**
+ * Calculate overall sentiment from analysis
+ *
+ * @param result - Analysis result
+ * @returns Sentiment score (-1 to 1) or null if not available
+ */
+function getOverallSentiment(result) {
+    return result.sentimentScores?.overall ?? null;
+}
+/**
+ * Determine if conversation needs attention based on patterns
+ *
+ * @param result - Analysis result
+ * @returns Whether the conversation needs attention
+ */
+function needsAttention(result) {
+    return (result.riskScore >= 50 ||
+        hasPiiExposure(result) ||
+        hasEscalationRequest(result) ||
+        result.insights.some(i => i.severity === 'critical'));
+}
+/**
+ * Get severity level as numeric value
+ *
+ * @param severity - Pattern severity
+ * @returns Numeric severity (1-3)
+ */
+function getSeverityLevel(severity) {
+    switch (severity) {
+        case 'info': return 1;
+        case 'warning': return 2;
+        case 'critical': return 3;
+        default: return 0;
+    }
+}
+/**
+ * Sort matches by severity (critical first)
+ *
+ * @param matches - Pattern matches to sort
+ * @returns Sorted matches
+ */
+function sortMatchesBySeverity(matches) {
+    return [...matches].sort((a, b) => getSeverityLevel(b.severity) - getSeverityLevel(a.severity));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcript-patterns.js","sourceRoot":"","sources":["../../src/api/transcript-patterns.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Transcript Patterns API\n *\n * API for transcript pattern detection and analysis\n */\n\nimport { apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type PatternCategory =\n  | 'frustration'\n  | 'confusion'\n  | 'success'\n  | 'failure'\n  | 'escalation'\n  | 'pii_exposure'\n  | 'hallucination'\n  | 'custom';\n\nexport type PatternOutcome = 'success' | 'failure' | 'escalation' | 'neutral';\nexport type PatternSeverity = 'info' | 'warning' | 'critical';\nexport type DetectionType = 'sequence' | 'keywords' | 'regex';\n\nexport interface PatternMatch {\n  patternId: string;\n  patternName: string;\n  category: PatternCategory;\n  matchedText?: string;\n  position?: { start: number; end: number };\n  confidence: number;\n  severity: PatternSeverity;\n}\n\nexport interface PatternInsight {\n  type: string;\n  message: string;\n  severity: PatternSeverity;\n  recommendation?: string;\n}\n\nexport interface AnalysisResult {\n  traceId: string;\n  sessionId?: string;\n  patternsMatched: number;\n  riskScore: number;\n  predictedOutcome?: PatternOutcome;\n  predictionConfidence?: number;\n  matches: PatternMatch[];\n  insights: PatternInsight[];\n  sentimentScores?: {\n    overall: number;\n    byTurn?: Array<{ turn: number; sentiment: number; confidence: number }>;\n  };\n}\n\nexport interface BulkAnalysisResult {\n  results: Array<AnalysisResult & { error?: string }>;\n  summary: {\n    tracesAnalyzed: number;\n    totalMatches: number;\n    tracesWithMatches: number;\n  };\n}\n\nexport interface PatternCategoryInfo {\n  id: PatternCategory;\n  name: string;\n  description: string;\n  indicators: string[];\n}\n\nexport interface BuiltInPattern {\n  id: string;\n  name: string;\n  category: PatternCategory;\n  detectionType: DetectionType;\n  description: string;\n}\n\n// ============================================================================\n// TRANSCRIPT PATTERNS API CLIENT\n// ============================================================================\n\n/**\n * Transcript Patterns API client for pattern detection and analysis\n */\nexport const transcriptPatterns = {\n  /**\n   * Analyze a trace for patterns\n   *\n   * @example\n   * ```typescript\n   * const result = await transcriptPatterns.analyze('trace_123');\n   * console.log(`Found ${result.patternsMatched} patterns`);\n   * console.log(`Risk score: ${result.riskScore}`);\n   * ```\n   */\n  async analyze(traceId: string): Promise<AnalysisResult> {\n    return apiRequestWithData<AnalysisResult>('/transcript-patterns/analyze', {\n      method: 'POST',\n      body: { traceId },\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Analyze multiple traces for patterns\n   *\n   * @example\n   * ```typescript\n   * const { results, summary } = await transcriptPatterns.bulkAnalyze([\n   *   'trace_1', 'trace_2', 'trace_3'\n   * ]);\n   * console.log(`${summary.tracesWithMatches} traces have patterns`);\n   * ```\n   */\n  async bulkAnalyze(traceIds: string[]): Promise<BulkAnalysisResult> {\n    return apiRequestWithData<BulkAnalysisResult>('/transcript-patterns/bulk-analyze', {\n      method: 'POST',\n      body: { traceIds },\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get available pattern categories with descriptions\n   *\n   * @example\n   * ```typescript\n   * const categories = await transcriptPatterns.getCategories();\n   * for (const category of categories) {\n   *   console.log(`${category.name}: ${category.description}`);\n   * }\n   * ```\n   */\n  async getCategories(): Promise<PatternCategoryInfo[]> {\n    return apiRequestWithData<PatternCategoryInfo[]>(\n      '/transcript-patterns/categories',\n      { apiVersion: 'v1' }\n    );\n  },\n\n  /**\n   * Get built-in patterns\n   *\n   * @example\n   * ```typescript\n   * const patterns = await transcriptPatterns.getBuiltInPatterns();\n   * const frustrationPatterns = patterns.filter(p => p.category === 'frustration');\n   * ```\n   */\n  async getBuiltInPatterns(): Promise<BuiltInPattern[]> {\n    return apiRequestWithData<BuiltInPattern[]>(\n      '/transcript-patterns/built-in',\n      { apiVersion: 'v1' }\n    );\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Check if analysis result indicates high risk\n *\n * @param result - Analysis result to check\n * @param threshold - Risk score threshold (default 70)\n * @returns Whether the result indicates high risk\n */\nexport function isHighRisk(result: AnalysisResult, threshold = 70): boolean {\n  return result.riskScore >= threshold;\n}\n\n/**\n * Get matches by category\n *\n * @param result - Analysis result\n * @param category - Pattern category to filter by\n * @returns Filtered pattern matches\n */\nexport function getMatchesByCategory(\n  result: AnalysisResult,\n  category: PatternCategory\n): PatternMatch[] {\n  return result.matches.filter(m => m.category === category);\n}\n\n/**\n * Get critical insights from analysis\n *\n * @param result - Analysis result\n * @returns Critical severity insights\n */\nexport function getCriticalInsights(result: AnalysisResult): PatternInsight[] {\n  return result.insights.filter(i => i.severity === 'critical');\n}\n\n/**\n * Check if analysis detected PII\n *\n * @param result - Analysis result\n * @returns Whether PII was detected\n */\nexport function hasPiiExposure(result: AnalysisResult): boolean {\n  return result.matches.some(m => m.category === 'pii_exposure');\n}\n\n/**\n * Check if analysis detected frustration\n *\n * @param result - Analysis result\n * @returns Whether frustration was detected\n */\nexport function hasFrustrationSignals(result: AnalysisResult): boolean {\n  return result.matches.some(m => m.category === 'frustration');\n}\n\n/**\n * Check if analysis detected escalation request\n *\n * @param result - Analysis result\n * @returns Whether escalation was requested\n */\nexport function hasEscalationRequest(result: AnalysisResult): boolean {\n  return result.matches.some(m => m.category === 'escalation');\n}\n\n/**\n * Calculate category distribution\n *\n * @param result - Analysis result\n * @returns Object with counts per category\n */\nexport function getCategoryDistribution(result: AnalysisResult): Record<PatternCategory, number> {\n  const distribution: Record<PatternCategory, number> = {\n    frustration: 0,\n    confusion: 0,\n    success: 0,\n    failure: 0,\n    escalation: 0,\n    pii_exposure: 0,\n    hallucination: 0,\n    custom: 0,\n  };\n\n  for (const match of result.matches) {\n    distribution[match.category]++;\n  }\n\n  return distribution;\n}\n\n/**\n * Get actionable recommendations from insights\n *\n * @param result - Analysis result\n * @returns Array of recommendation strings\n */\nexport function getRecommendations(result: AnalysisResult): string[] {\n  return result.insights\n    .filter(i => i.recommendation)\n    .map(i => i.recommendation as string);\n}\n\n/**\n * Calculate overall sentiment from analysis\n *\n * @param result - Analysis result\n * @returns Sentiment score (-1 to 1) or null if not available\n */\nexport function getOverallSentiment(result: AnalysisResult): number | null {\n  return result.sentimentScores?.overall ?? null;\n}\n\n/**\n * Determine if conversation needs attention based on patterns\n *\n * @param result - Analysis result\n * @returns Whether the conversation needs attention\n */\nexport function needsAttention(result: AnalysisResult): boolean {\n  return (\n    result.riskScore >= 50 ||\n    hasPiiExposure(result) ||\n    hasEscalationRequest(result) ||\n    result.insights.some(i => i.severity === 'critical')\n  );\n}\n\n/**\n * Get severity level as numeric value\n *\n * @param severity - Pattern severity\n * @returns Numeric severity (1-3)\n */\nexport function getSeverityLevel(severity: PatternSeverity): number {\n  switch (severity) {\n    case 'info': return 1;\n    case 'warning': return 2;\n    case 'critical': return 3;\n    default: return 0;\n  }\n}\n\n/**\n * Sort matches by severity (critical first)\n *\n * @param matches - Pattern matches to sort\n * @returns Sorted matches\n */\nexport function sortMatchesBySeverity(matches: PatternMatch[]): PatternMatch[] {\n  return [...matches].sort((a, b) => getSeverityLevel(b.severity) - getSeverityLevel(a.severity));\n}\n"]}

package/dist/core/client.d.ts

@@ -4,26 +4,100 @@
  * Centralized HTTP client with authentication and error handling
  */
 export interface RequestOptions {
-    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
     body?: unknown;
     headers?: Record<string, string>;
     /** Override API version for this request */
-    apiVersion?: 'v1' | 'v3';
+    apiVersion?: 'v1' | 'v2' | 'v3';
+    /** Override max retries for this request */
+    maxRetries?: number;
+    /** Request timeout in milliseconds */
+    timeout?: number;
 }
 /**
- * Make an authenticated API request
+ * Make an authenticated API request with retry logic
  */
 export declare function apiRequest<T>(path: string, options?: RequestOptions): Promise<T>;
 /**
  * Make an API request and extract data from response wrapper
  */
 export declare function apiRequestWithData<T>(path: string, options?: RequestOptions): Promise<T>;
-export declare class ThinkHiveApiError extends Error {
-    readonly statusCode: number;
-    readonly code?: string | undefined;
-    constructor(message: string, statusCode: number, code?: string | undefined);
+/**
+ * Base error class for ThinkHive SDK errors
+ */
+export declare class ThinkHiveError extends Error {
+    readonly code: string;
+    readonly statusCode?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined, details?: Record<string, unknown> | undefined);
+}
+/**
+ * API request error - returned from ThinkHive server
+ */
+export declare class ThinkHiveApiError extends ThinkHiveError {
+    constructor(message: string, statusCode: number, code?: string);
 }
-export declare class ThinkHiveValidationError extends Error {
+/**
+ * Validation error - invalid input parameters
+ */
+export declare class ThinkHiveValidationError extends ThinkHiveError {
     readonly field?: string | undefined;
     constructor(message: string, field?: string | undefined);
 }
+/**
+ * Permission denied error - API key lacks required permissions
+ * @example
+ * ```typescript
+ * try {
+ *   await thinkHive.traces.create(...);
+ * } catch (error) {
+ *   if (error instanceof PermissionDeniedError) {
+ *     console.log('API key needs write permission');
+ *   }
+ * }
+ * ```
+ */
+export declare class PermissionDeniedError extends ThinkHiveError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/**
+ * Agent scope violation error - API key not authorized for this agent
+ * @example
+ * ```typescript
+ * // Create key scoped to specific agents
+ * const key = await thinkHive.apiKeys.create({
+ *   name: 'Agent A Key',
+ *   allowedAgentIds: ['agent-a-id']
+ * });
+ *
+ * // Attempting to use for Agent B will throw AgentScopeError
+ * ```
+ */
+export declare class AgentScopeError extends ThinkHiveError {
+    constructor(agentId: string, allowedAgents: string[]);
+}
+/**
+ * Rate limit exceeded error
+ * @example
+ * ```typescript
+ * try {
+ *   await thinkHive.traces.create(...);
+ * } catch (error) {
+ *   if (error instanceof RateLimitError) {
+ *     // Wait and retry
+ *     await sleep(error.retryAfter);
+ *     await thinkHive.traces.create(...);
+ *   }
+ * }
+ * ```
+ */
+export declare class RateLimitError extends ThinkHiveError {
+    readonly retryAfter: number;
+    constructor(retryAfter: number);
+}
+/**
+ * IP whitelist violation error
+ */
+export declare class IpWhitelistError extends ThinkHiveError {
+    constructor(clientIp: string);
+}