@thinkhive/sdk 2.0.1 → 3.0.0

package/dist/integrations/customer-context.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Customer Context
+ *
+ * Time-series customer metrics snapshots
+ * Captures ARR, health score, segment AS OF the run time (not current values)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customerContext = void 0;
+exports.toContextSnapshot = toContextSnapshot;
+exports.captureCustomerContext = captureCustomerContext;
+exports.getContextAsOf = getContextAsOf;
+exports.calculateArrChange = calculateArrChange;
+exports.calculateHealthTrend = calculateHealthTrend;
+const client_1 = require("../core/client");
+// ============================================================================
+// CUSTOMER CONTEXT API
+// ============================================================================
+/**
+ * Customer context API client for time-series metrics
+ */
+exports.customerContext = {
+    /**
+     * Create a customer account
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.createAccount({
+     *   name: 'Acme Corp',
+     *   externalId: 'sf_001234',
+     *   externalSource: 'salesforce',
+     *   segment: 'enterprise',
+     * });
+     * ```
+     */
+    async createAccount(input) {
+        return (0, client_1.apiRequestWithData)('/customers', {
+            method: 'POST',
+            body: input,
+        });
+    },
+    /**
+     * Get a customer account by ID
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.getAccount('cust_abc123');
+     * ```
+     */
+    async getAccount(customerId) {
+        return (0, client_1.apiRequestWithData)(`/customers/${customerId}`);
+    },
+    /**
+     * Get a customer account by external ID
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.getAccountByExternalId(
+     *   'sf_001234',
+     *   'salesforce'
+     * );
+     * ```
+     */
+    async getAccountByExternalId(externalId, source) {
+        try {
+            return await (0, client_1.apiRequestWithData)(`/customers/external/${source}/${externalId}`);
+        }
+        catch (error) {
+            if (error?.statusCode === 404) {
+                return null;
+            }
+            throw error;
+        }
+    },
+    /**
+     * Capture a metrics snapshot for a customer
+     * This creates a point-in-time record of the customer's metrics
+     *
+     * @example
+     * ```typescript
+     * // Capture current metrics
+     * const snapshot = await customerContext.captureSnapshot('cust_abc123', {
+     *   arr: 120000,
+     *   healthScore: 85,
+     *   nps: 45,
+     *   segment: 'enterprise',
+     * });
+     *
+     * // Use this snapshot in a run
+     * const run = await runs.create({
+     *   agentId: 'agent_123',
+     *   customerContext: {
+     *     customerId: 'cust_abc123',
+     *     arr: snapshot.arr,
+     *     healthScore: snapshot.healthScore,
+     *     capturedAt: snapshot.capturedAt,
+     *   },
+     *   // ...
+     * });
+     * ```
+     */
+    async captureSnapshot(customerId, metrics) {
+        return (0, client_1.apiRequestWithData)(`/customers/${customerId}/snapshots`, {
+            method: 'POST',
+            body: {
+                ...metrics,
+                capturedAt: new Date().toISOString(),
+            },
+        });
+    },
+    /**
+     * Get metrics snapshots for a customer (time-series)
+     *
+     * @example
+     * ```typescript
+     * // Get last 30 days of snapshots
+     * const snapshots = await customerContext.getSnapshots('cust_abc123', {
+     *   from: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+     * });
+     * ```
+     */
+    async getSnapshots(customerId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.from)
+            params.set('from', options.from);
+        if (options.to)
+            params.set('to', options.to);
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        return (0, client_1.apiRequestWithData)(`/customers/${customerId}/snapshots?${params.toString()}`);
+    },
+    /**
+     * Get the most recent snapshot for a customer
+     *
+     * @example
+     * ```typescript
+     * const latest = await customerContext.getLatestSnapshot('cust_abc123');
+     * ```
+     */
+    async getLatestSnapshot(customerId) {
+        try {
+            return await (0, client_1.apiRequestWithData)(`/customers/${customerId}/snapshots/latest`);
+        }
+        catch (error) {
+            if (error?.statusCode === 404) {
+                return null;
+            }
+            throw error;
+        }
+    },
+    /**
+     * Get snapshot closest to a specific timestamp
+     * Useful for retroactive analysis
+     *
+     * @example
+     * ```typescript
+     * // Get metrics as of a specific date
+     * const snapshot = await customerContext.getSnapshotAsOf(
+     *   'cust_abc123',
+     *   '2024-01-15T10:00:00Z'
+     * );
+     * ```
+     */
+    async getSnapshotAsOf(customerId, timestamp) {
+        const ts = new Date(timestamp).toISOString();
+        try {
+            return await (0, client_1.apiRequestWithData)(`/customers/${customerId}/snapshots/as-of?timestamp=${encodeURIComponent(ts)}`);
+        }
+        catch (error) {
+            if (error?.statusCode === 404) {
+                return null;
+            }
+            throw error;
+        }
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Create a CustomerContextSnapshot from a metrics snapshot
+ */
+function toContextSnapshot(snapshot) {
+    return {
+        customerId: snapshot.customerAccountId,
+        arr: snapshot.arr,
+        healthScore: snapshot.healthScore,
+        segment: snapshot.segment,
+        capturedAt: snapshot.capturedAt,
+    };
+}
+/**
+ * Capture metrics and create context snapshot in one call
+ *
+ * @example
+ * ```typescript
+ * const context = await captureCustomerContext('cust_abc123', {
+ *   arr: 100000,
+ *   healthScore: 90,
+ *   segment: 'enterprise',
+ * });
+ *
+ * // Use in run
+ * const run = await runs.create({
+ *   agentId: 'agent_123',
+ *   customerContext: context,
+ *   // ...
+ * });
+ * ```
+ */
+async function captureCustomerContext(customerId, metrics) {
+    const snapshot = await exports.customerContext.captureSnapshot(customerId, metrics);
+    return toContextSnapshot(snapshot);
+}
+/**
+ * Get customer context as of a specific time
+ */
+async function getContextAsOf(customerId, timestamp) {
+    const snapshot = await exports.customerContext.getSnapshotAsOf(customerId, timestamp);
+    return snapshot ? toContextSnapshot(snapshot) : null;
+}
+/**
+ * Calculate ARR change between two snapshots
+ */
+function calculateArrChange(older, newer) {
+    const oldArr = older.arr || 0;
+    const newArr = newer.arr || 0;
+    const absolute = newArr - oldArr;
+    const percentage = oldArr > 0 ? (absolute / oldArr) * 100 : 0;
+    return {
+        absolute,
+        percentage,
+        direction: absolute > 0 ? 'increase' : absolute < 0 ? 'decrease' : 'stable',
+    };
+}
+/**
+ * Calculate health score trend
+ */
+function calculateHealthTrend(snapshots) {
+    const scores = snapshots
+        .filter((s) => s.healthScore !== undefined && s.healthScore !== null)
+        .map((s) => s.healthScore);
+    if (scores.length === 0) {
+        return {
+            currentScore: null,
+            avgScore: null,
+            trend: 'stable',
+            volatility: 'low',
+        };
+    }
+    const currentScore = scores[0];
+    const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+    // Calculate trend (simple linear regression direction)
+    let trend = 'stable';
+    if (scores.length >= 2) {
+        const recentAvg = scores.slice(0, Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.ceil(scores.length / 2);
+        const olderAvg = scores.slice(Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.floor(scores.length / 2);
+        if (recentAvg - olderAvg > 5)
+            trend = 'improving';
+        else if (olderAvg - recentAvg > 5)
+            trend = 'declining';
+    }
+    // Calculate volatility (standard deviation)
+    const variance = scores.reduce((acc, s) => acc + Math.pow(s - avgScore, 2), 0) / scores.length;
+    const stdDev = Math.sqrt(variance);
+    const volatility = stdDev < 5 ? 'low' : stdDev < 15 ? 'medium' : 'high';
+    return {
+        currentScore,
+        avgScore,
+        trend,
+        volatility,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"customer-context.js","sourceRoot":"","sources":["../../src/integrations/customer-context.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Customer Context\n *\n * Time-series customer metrics snapshots\n * Captures ARR, health score, segment AS OF the run time (not current values)\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type { CustomerContextSnapshot } from '../core/types';\n\n// ============================================================================\n// CUSTOMER ACCOUNT TYPES\n// ============================================================================\n\nexport interface CustomerAccount {\n  id: string;\n  companyId: string;\n  externalId?: string;\n  externalSource?: 'salesforce' | 'hubspot' | 'zendesk' | 'intercom' | 'custom';\n  name: string;\n  domain?: string;\n  segment?: string;\n  industry?: string;\n  employeeCount?: number;\n  createdAt: string;\n  updatedAt: string;\n}\n\nexport interface CustomerMetricsSnapshot {\n  id: string;\n  customerAccountId: string;\n  arr?: number;\n  healthScore?: number;\n  nps?: number;\n  segment?: string;\n  churnRisk?: 'low' | 'medium' | 'high';\n  capturedAt: string;\n  source?: string;\n  createdAt: string;\n}\n\n// ============================================================================\n// CUSTOMER CONTEXT API\n// ============================================================================\n\n/**\n * Customer context API client for time-series metrics\n */\nexport const customerContext = {\n  /**\n   * Create a customer account\n   *\n   * @example\n   * ```typescript\n   * const account = await customerContext.createAccount({\n   *   name: 'Acme Corp',\n   *   externalId: 'sf_001234',\n   *   externalSource: 'salesforce',\n   *   segment: 'enterprise',\n   * });\n   * ```\n   */\n  async createAccount(input: {\n    name: string;\n    externalId?: string;\n    externalSource?: CustomerAccount['externalSource'];\n    domain?: string;\n    segment?: string;\n    industry?: string;\n    employeeCount?: number;\n  }): Promise<CustomerAccount> {\n    return apiRequestWithData<CustomerAccount>('/customers', {\n      method: 'POST',\n      body: input,\n    });\n  },\n\n  /**\n   * Get a customer account by ID\n   *\n   * @example\n   * ```typescript\n   * const account = await customerContext.getAccount('cust_abc123');\n   * ```\n   */\n  async getAccount(customerId: string): Promise<CustomerAccount> {\n    return apiRequestWithData<CustomerAccount>(`/customers/${customerId}`);\n  },\n\n  /**\n   * Get a customer account by external ID\n   *\n   * @example\n   * ```typescript\n   * const account = await customerContext.getAccountByExternalId(\n   *   'sf_001234',\n   *   'salesforce'\n   * );\n   * ```\n   */\n  async getAccountByExternalId(\n    externalId: string,\n    source: CustomerAccount['externalSource']\n  ): Promise<CustomerAccount | null> {\n    try {\n      return await apiRequestWithData<CustomerAccount>(\n        `/customers/external/${source}/${externalId}`\n      );\n    } catch (error) {\n      if ((error as any)?.statusCode === 404) {\n        return null;\n      }\n      throw error;\n    }\n  },\n\n  /**\n   * Capture a metrics snapshot for a customer\n   * This creates a point-in-time record of the customer's metrics\n   *\n   * @example\n   * ```typescript\n   * // Capture current metrics\n   * const snapshot = await customerContext.captureSnapshot('cust_abc123', {\n   *   arr: 120000,\n   *   healthScore: 85,\n   *   nps: 45,\n   *   segment: 'enterprise',\n   * });\n   *\n   * // Use this snapshot in a run\n   * const run = await runs.create({\n   *   agentId: 'agent_123',\n   *   customerContext: {\n   *     customerId: 'cust_abc123',\n   *     arr: snapshot.arr,\n   *     healthScore: snapshot.healthScore,\n   *     capturedAt: snapshot.capturedAt,\n   *   },\n   *   // ...\n   * });\n   * ```\n   */\n  async captureSnapshot(\n    customerId: string,\n    metrics: {\n      arr?: number;\n      healthScore?: number;\n      nps?: number;\n      segment?: string;\n      churnRisk?: 'low' | 'medium' | 'high';\n      source?: string;\n    }\n  ): Promise<CustomerMetricsSnapshot> {\n    return apiRequestWithData<CustomerMetricsSnapshot>(\n      `/customers/${customerId}/snapshots`,\n      {\n        method: 'POST',\n        body: {\n          ...metrics,\n          capturedAt: new Date().toISOString(),\n        },\n      }\n    );\n  },\n\n  /**\n   * Get metrics snapshots for a customer (time-series)\n   *\n   * @example\n   * ```typescript\n   * // Get last 30 days of snapshots\n   * const snapshots = await customerContext.getSnapshots('cust_abc123', {\n   *   from: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),\n   * });\n   * ```\n   */\n  async getSnapshots(\n    customerId: string,\n    options: {\n      from?: string;\n      to?: string;\n      limit?: number;\n    } = {}\n  ): Promise<CustomerMetricsSnapshot[]> {\n    const params = new URLSearchParams();\n    if (options.from) params.set('from', options.from);\n    if (options.to) params.set('to', options.to);\n    if (options.limit) params.set('limit', String(options.limit));\n\n    return apiRequestWithData<CustomerMetricsSnapshot[]>(\n      `/customers/${customerId}/snapshots?${params.toString()}`\n    );\n  },\n\n  /**\n   * Get the most recent snapshot for a customer\n   *\n   * @example\n   * ```typescript\n   * const latest = await customerContext.getLatestSnapshot('cust_abc123');\n   * ```\n   */\n  async getLatestSnapshot(\n    customerId: string\n  ): Promise<CustomerMetricsSnapshot | null> {\n    try {\n      return await apiRequestWithData<CustomerMetricsSnapshot>(\n        `/customers/${customerId}/snapshots/latest`\n      );\n    } catch (error) {\n      if ((error as any)?.statusCode === 404) {\n        return null;\n      }\n      throw error;\n    }\n  },\n\n  /**\n   * Get snapshot closest to a specific timestamp\n   * Useful for retroactive analysis\n   *\n   * @example\n   * ```typescript\n   * // Get metrics as of a specific date\n   * const snapshot = await customerContext.getSnapshotAsOf(\n   *   'cust_abc123',\n   *   '2024-01-15T10:00:00Z'\n   * );\n   * ```\n   */\n  async getSnapshotAsOf(\n    customerId: string,\n    timestamp: string | Date\n  ): Promise<CustomerMetricsSnapshot | null> {\n    const ts = new Date(timestamp).toISOString();\n    try {\n      return await apiRequestWithData<CustomerMetricsSnapshot>(\n        `/customers/${customerId}/snapshots/as-of?timestamp=${encodeURIComponent(ts)}`\n      );\n    } catch (error) {\n      if ((error as any)?.statusCode === 404) {\n        return null;\n      }\n      throw error;\n    }\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Create a CustomerContextSnapshot from a metrics snapshot\n */\nexport function toContextSnapshot(\n  snapshot: CustomerMetricsSnapshot\n): CustomerContextSnapshot {\n  return {\n    customerId: snapshot.customerAccountId,\n    arr: snapshot.arr,\n    healthScore: snapshot.healthScore,\n    segment: snapshot.segment,\n    capturedAt: snapshot.capturedAt,\n  };\n}\n\n/**\n * Capture metrics and create context snapshot in one call\n *\n * @example\n * ```typescript\n * const context = await captureCustomerContext('cust_abc123', {\n *   arr: 100000,\n *   healthScore: 90,\n *   segment: 'enterprise',\n * });\n *\n * // Use in run\n * const run = await runs.create({\n *   agentId: 'agent_123',\n *   customerContext: context,\n *   // ...\n * });\n * ```\n */\nexport async function captureCustomerContext(\n  customerId: string,\n  metrics: {\n    arr?: number;\n    healthScore?: number;\n    segment?: string;\n  }\n): Promise<CustomerContextSnapshot> {\n  const snapshot = await customerContext.captureSnapshot(customerId, metrics);\n  return toContextSnapshot(snapshot);\n}\n\n/**\n * Get customer context as of a specific time\n */\nexport async function getContextAsOf(\n  customerId: string,\n  timestamp: string | Date\n): Promise<CustomerContextSnapshot | null> {\n  const snapshot = await customerContext.getSnapshotAsOf(customerId, timestamp);\n  return snapshot ? toContextSnapshot(snapshot) : null;\n}\n\n/**\n * Calculate ARR change between two snapshots\n */\nexport function calculateArrChange(\n  older: CustomerMetricsSnapshot,\n  newer: CustomerMetricsSnapshot\n): {\n  absolute: number;\n  percentage: number;\n  direction: 'increase' | 'decrease' | 'stable';\n} {\n  const oldArr = older.arr || 0;\n  const newArr = newer.arr || 0;\n  const absolute = newArr - oldArr;\n  const percentage = oldArr > 0 ? (absolute / oldArr) * 100 : 0;\n\n  return {\n    absolute,\n    percentage,\n    direction: absolute > 0 ? 'increase' : absolute < 0 ? 'decrease' : 'stable',\n  };\n}\n\n/**\n * Calculate health score trend\n */\nexport function calculateHealthTrend(\n  snapshots: CustomerMetricsSnapshot[]\n): {\n  currentScore: number | null;\n  avgScore: number | null;\n  trend: 'improving' | 'declining' | 'stable';\n  volatility: 'low' | 'medium' | 'high';\n} {\n  const scores = snapshots\n    .filter((s) => s.healthScore !== undefined && s.healthScore !== null)\n    .map((s) => s.healthScore!);\n\n  if (scores.length === 0) {\n    return {\n      currentScore: null,\n      avgScore: null,\n      trend: 'stable',\n      volatility: 'low',\n    };\n  }\n\n  const currentScore = scores[0];\n  const avgScore = scores.reduce((a, b) => a + b, 0) / scores.length;\n\n  // Calculate trend (simple linear regression direction)\n  let trend: 'improving' | 'declining' | 'stable' = 'stable';\n  if (scores.length >= 2) {\n    const recentAvg = scores.slice(0, Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.ceil(scores.length / 2);\n    const olderAvg = scores.slice(Math.ceil(scores.length / 2)).reduce((a, b) => a + b, 0) / Math.floor(scores.length / 2);\n    if (recentAvg - olderAvg > 5) trend = 'improving';\n    else if (olderAvg - recentAvg > 5) trend = 'declining';\n  }\n\n  // Calculate volatility (standard deviation)\n  const variance = scores.reduce((acc, s) => acc + Math.pow(s - avgScore, 2), 0) / scores.length;\n  const stdDev = Math.sqrt(variance);\n  const volatility = stdDev < 5 ? 'low' : stdDev < 15 ? 'medium' : 'high';\n\n  return {\n    currentScore,\n    avgScore,\n    trend,\n    volatility,\n  };\n}\n"]}

package/dist/integrations/ticket-linking.d.ts

@@ -0,0 +1,217 @@
+/**
+ * ThinkHive SDK v3.0 - Ticket Linking
+ *
+ * Deterministic linking between runs and support tickets
+ * 7 link methods with explicit confidence scores
+ */
+import type { LinkMethod } from '../core/types';
+/**
+ * Generate a Zendesk marker to embed in agent responses
+ *
+ * @example
+ * ```typescript
+ * const runId = 'run_abc123';
+ * const marker = generateZendeskMarker(runId);
+ * // Returns: '[THID:run_abc123]'
+ *
+ * // Append to your agent response:
+ * const response = `I've found your order. ${marker}`;
+ * ```
+ */
+export declare function generateZendeskMarker(runId: string): string;
+/**
+ * Parse a Zendesk marker from text
+ *
+ * @example
+ * ```typescript
+ * const text = 'Thank you for contacting us. [THID:run_abc123]';
+ * const runId = parseZendeskMarker(text);
+ * // Returns: 'run_abc123'
+ * ```
+ */
+export declare function parseZendeskMarker(text: string): string | null;
+/**
+ * Check if text contains a Zendesk marker
+ */
+export declare function hasZendeskMarker(text: string): boolean;
+/**
+ * Remove Zendesk marker from text (for clean display)
+ *
+ * @example
+ * ```typescript
+ * const text = 'Thank you! [THID:run_abc123]';
+ * const clean = removeZendeskMarker(text);
+ * // Returns: 'Thank you!'
+ * ```
+ */
+export declare function removeZendeskMarker(text: string): string;
+/**
+ * Confidence scores for each link method
+ * Based on deterministic linking principles from v3 spec
+ */
+export declare const LINK_METHOD_CONFIDENCE: Record<LinkMethod, number>;
+/**
+ * Link evidence structure
+ */
+export interface LinkEvidence {
+    method: LinkMethod;
+    confidence: number;
+    timestamp: string;
+    details: {
+        runId?: string;
+        ticketId?: string;
+        externalTicketId?: string;
+        platform?: string;
+        sessionId?: string;
+        email?: string;
+        timeWindowMinutes?: number;
+        customFieldName?: string;
+        customFieldValue?: string;
+    };
+}
+/**
+ * Create link input
+ */
+export interface CreateLinkInput {
+    runId: string;
+    ticketId?: string;
+    externalTicketId?: string;
+    platform?: 'zendesk' | 'intercom' | 'salesforce' | 'freshdesk';
+    method: LinkMethod;
+    evidence?: Partial<LinkEvidence['details']>;
+}
+/**
+ * Link response
+ */
+export interface LinkResponse {
+    id: string;
+    runId: string;
+    ticketId?: string;
+    externalTicketId?: string;
+    platform?: string;
+    method: LinkMethod;
+    confidence: number;
+    evidence: LinkEvidence;
+    createdAt: string;
+}
+/**
+ * Linking API client
+ */
+export declare const linking: {
+    /**
+     * Create a link between a run and a ticket
+     *
+     * @example
+     * ```typescript
+     * // SDK explicit linking (highest confidence)
+     * const link = await linking.create({
+     *   runId: 'run_abc123',
+     *   ticketId: 'ticket_xyz',
+     *   method: 'sdk_explicit',
+     * });
+     *
+     * // Zendesk marker linking
+     * const link = await linking.create({
+     *   runId: 'run_abc123',
+     *   externalTicketId: '12345',
+     *   platform: 'zendesk',
+     *   method: 'zendesk_marker',
+     * });
+     * ```
+     */
+    create(input: CreateLinkInput): Promise<LinkResponse>;
+    /**
+     * Get links for a run
+     *
+     * @example
+     * ```typescript
+     * const links = await linking.getForRun('run_abc123');
+     * ```
+     */
+    getForRun(runId: string): Promise<LinkResponse[]>;
+    /**
+     * Get links for a ticket
+     *
+     * @example
+     * ```typescript
+     * const links = await linking.getForTicket('ticket_xyz');
+     * ```
+     */
+    getForTicket(ticketId: string): Promise<LinkResponse[]>;
+    /**
+     * Verify a link (confirm or reject)
+     *
+     * @example
+     * ```typescript
+     * await linking.verify('link_abc123', {
+     *   verified: true,
+     *   notes: 'Confirmed by support agent',
+     * });
+     * ```
+     */
+    verify(linkId: string, options: {
+        verified: boolean;
+        notes?: string;
+    }): Promise<{
+        linkId: string;
+        verified: boolean;
+        message: string;
+    }>;
+    /**
+     * Delete a link
+     *
+     * @example
+     * ```typescript
+     * await linking.delete('link_abc123');
+     * ```
+     */
+    delete(linkId: string): Promise<void>;
+    /**
+     * Auto-link runs to tickets based on available evidence
+     *
+     * @example
+     * ```typescript
+     * const results = await linking.autoLink('run_abc123');
+     * for (const link of results.created) {
+     *   console.log(`Linked to ${link.ticketId} via ${link.method}`);
+     * }
+     * ```
+     */
+    autoLink(runId: string): Promise<{
+        runId: string;
+        created: LinkResponse[];
+        candidates: Array<{
+            ticketId: string;
+            method: LinkMethod;
+            confidence: number;
+            reason: string;
+        }>;
+    }>;
+};
+/**
+ * Create SDK explicit link (convenience function)
+ */
+export declare function linkRunToTicket(runId: string, ticketId: string): Promise<LinkResponse>;
+/**
+ * Create Zendesk link via marker
+ */
+export declare function linkRunToZendeskTicket(runId: string, zendeskTicketId: string): Promise<LinkResponse>;
+/**
+ * Get the best link method for a given scenario
+ */
+export declare function getBestLinkMethod(available: {
+    hasTicketId: boolean;
+    hasMarker: boolean;
+    hasCustomField: boolean;
+    hasMiddlewareStamp: boolean;
+    hasSessionId: boolean;
+    hasEmail: boolean;
+}): LinkMethod | null;
+/**
+ * Format link confidence for display
+ */
+export declare function formatLinkConfidence(confidence: number): string;
+/**
+ * Get confidence level label
+ */
+export declare function getConfidenceLevel(confidence: number): 'definitive' | 'high' | 'medium' | 'low';