@thinkhive/sdk 2.0.1 → 3.1.0

package/dist/instrumentation/openai.d.ts

@@ -0,0 +1,141 @@
+/**
+ * ThinkHive SDK v3.0 - OpenAI Instrumentation
+ *
+ * Auto-instrumentation for OpenAI API calls including:
+ * - Chat completions
+ * - Assistants API
+ * - Tool calls
+ */
+import type { ConversationMessage, SpanData } from '../core/types';
+/**
+ * Wrap an OpenAI chat completion call with tracing
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { wrapChatCompletion } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ *
+ * const result = await wrapChatCompletion(
+ *   () => openai.chat.completions.create({
+ *     model: 'gpt-4',
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   }),
+ *   {
+ *     model: 'gpt-4',
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   }
+ * );
+ * ```
+ */
+export declare function wrapChatCompletion<T>(fn: () => Promise<T>, options?: {
+    model?: string;
+    messages?: Array<{
+        role: string;
+        content: string;
+    }>;
+    temperature?: number;
+    maxTokens?: number;
+}): Promise<T>;
+/**
+ * Wrap an OpenAI Assistants API call with tracing
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { wrapAssistantRun } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ *
+ * const run = await wrapAssistantRun(
+ *   () => openai.beta.threads.runs.create(threadId, {
+ *     assistant_id: assistantId,
+ *   }),
+ *   { assistantId, threadId }
+ * );
+ * ```
+ */
+export declare function wrapAssistantRun<T>(fn: () => Promise<T>, options: {
+    assistantId: string;
+    threadId: string;
+    model?: string;
+}): Promise<T>;
+/**
+ * Wrap an OpenAI tool call with tracing
+ *
+ * @example
+ * ```typescript
+ * const result = await wrapToolCall(
+ *   () => executeMyTool(args),
+ *   {
+ *     toolName: 'search_orders',
+ *     toolCallId: 'call_abc123',
+ *     arguments: { orderId: '12345' },
+ *   }
+ * );
+ * ```
+ */
+export declare function wrapToolCall<T>(fn: () => Promise<T>, options: {
+    toolName: string;
+    toolCallId?: string;
+    arguments?: Record<string, unknown>;
+}): Promise<T>;
+/**
+ * Extract conversation messages from OpenAI format
+ */
+export declare function extractConversationMessages(openaiMessages: Array<{
+    role: string;
+    content: string | null;
+    tool_calls?: Array<{
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+}>): ConversationMessage[];
+/**
+ * Extract span data from OpenAI response
+ */
+export declare function extractSpanData(response: {
+    model?: string;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+    };
+    choices?: Array<{
+        message?: {
+            tool_calls?: Array<{
+                id: string;
+                function: {
+                    name: string;
+                    arguments: string;
+                };
+            }>;
+        };
+        finish_reason?: string;
+    }>;
+}, durationMs: number): SpanData;
+/**
+ * Auto-instrument OpenAI client
+ * Call this during SDK init to automatically trace all OpenAI calls
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { instrumentOpenAIClient } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ * instrumentOpenAIClient(openai);
+ *
+ * // All subsequent calls are automatically traced
+ * const response = await openai.chat.completions.create({ ... });
+ * ```
+ */
+export declare function instrumentOpenAIClient(client: any): void;
+/**
+ * Remove instrumentation from OpenAI client
+ */
+export declare function uninstrumentOpenAIClient(client: any, originalCreate: any): void;

package/dist/instrumentation/openai.js

@@ -0,0 +1,279 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - OpenAI Instrumentation
+ *
+ * Auto-instrumentation for OpenAI API calls including:
+ * - Chat completions
+ * - Assistants API
+ * - Tool calls
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapChatCompletion = wrapChatCompletion;
+exports.wrapAssistantRun = wrapAssistantRun;
+exports.wrapToolCall = wrapToolCall;
+exports.extractConversationMessages = extractConversationMessages;
+exports.extractSpanData = extractSpanData;
+exports.instrumentOpenAIClient = instrumentOpenAIClient;
+exports.uninstrumentOpenAIClient = uninstrumentOpenAIClient;
+const api_1 = require("@opentelemetry/api");
+const config_1 = require("../core/config");
+// ============================================================================
+// OPENAI TRACING
+// ============================================================================
+/**
+ * Wrap an OpenAI chat completion call with tracing
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { wrapChatCompletion } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ *
+ * const result = await wrapChatCompletion(
+ *   () => openai.chat.completions.create({
+ *     model: 'gpt-4',
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   }),
+ *   {
+ *     model: 'gpt-4',
+ *     messages: [{ role: 'user', content: 'Hello' }],
+ *   }
+ * );
+ * ```
+ */
+async function wrapChatCompletion(fn, options = {}) {
+    const tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    return tracer.startActiveSpan('openai.chat.completions', {
+        attributes: {
+            'openinference.span.kind': 'LLM',
+            'llm.provider': 'openai',
+            'llm.model_name': options.model,
+            'llm.temperature': options.temperature,
+            'llm.max_tokens': options.maxTokens,
+            'llm.input_messages': options.messages
+                ? JSON.stringify(options.messages).substring(0, 10000)
+                : undefined,
+        },
+    }, async (span) => {
+        const startTime = Date.now();
+        try {
+            const result = await fn();
+            // Extract response data
+            const response = result;
+            if (response?.choices?.[0]?.message) {
+                span.setAttribute('llm.output_messages', JSON.stringify(response.choices[0].message).substring(0, 10000));
+            }
+            if (response?.usage) {
+                span.setAttribute('llm.token_count.prompt', response.usage.prompt_tokens);
+                span.setAttribute('llm.token_count.completion', response.usage.completion_tokens);
+                span.setAttribute('llm.token_count.total', response.usage.total_tokens);
+            }
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.setAttribute('duration_ms', Date.now() - startTime);
+            span.end();
+        }
+    });
+}
+/**
+ * Wrap an OpenAI Assistants API call with tracing
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { wrapAssistantRun } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ *
+ * const run = await wrapAssistantRun(
+ *   () => openai.beta.threads.runs.create(threadId, {
+ *     assistant_id: assistantId,
+ *   }),
+ *   { assistantId, threadId }
+ * );
+ * ```
+ */
+async function wrapAssistantRun(fn, options) {
+    const tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    return tracer.startActiveSpan('openai.assistants.run', {
+        attributes: {
+            'openinference.span.kind': 'AGENT',
+            'llm.provider': 'openai',
+            'llm.model_name': options.model,
+            'assistant.id': options.assistantId,
+            'assistant.thread_id': options.threadId,
+        },
+    }, async (span) => {
+        const startTime = Date.now();
+        try {
+            const result = await fn();
+            const response = result;
+            if (response?.status) {
+                span.setAttribute('assistant.run_status', response.status);
+            }
+            if (response?.usage) {
+                span.setAttribute('llm.token_count.prompt', response.usage.prompt_tokens);
+                span.setAttribute('llm.token_count.completion', response.usage.completion_tokens);
+            }
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.setAttribute('duration_ms', Date.now() - startTime);
+            span.end();
+        }
+    });
+}
+/**
+ * Wrap an OpenAI tool call with tracing
+ *
+ * @example
+ * ```typescript
+ * const result = await wrapToolCall(
+ *   () => executeMyTool(args),
+ *   {
+ *     toolName: 'search_orders',
+ *     toolCallId: 'call_abc123',
+ *     arguments: { orderId: '12345' },
+ *   }
+ * );
+ * ```
+ */
+async function wrapToolCall(fn, options) {
+    const tracer = api_1.trace.getTracer('thinkhive', '3.0.0');
+    return tracer.startActiveSpan(`tool.${options.toolName}`, {
+        attributes: {
+            'openinference.span.kind': 'TOOL',
+            'tool.name': options.toolName,
+            'tool.call_id': options.toolCallId,
+            'tool.parameters': options.arguments
+                ? JSON.stringify(options.arguments).substring(0, 10000)
+                : undefined,
+        },
+    }, async (span) => {
+        const startTime = Date.now();
+        try {
+            const result = await fn();
+            span.setAttribute('tool.output', JSON.stringify(result).substring(0, 10000));
+            span.setStatus({ code: api_1.SpanStatusCode.OK });
+            return result;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: api_1.SpanStatusCode.ERROR, message });
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.setAttribute('duration_ms', Date.now() - startTime);
+            span.end();
+        }
+    });
+}
+// ============================================================================
+// EXTRACTION HELPERS
+// ============================================================================
+/**
+ * Extract conversation messages from OpenAI format
+ */
+function extractConversationMessages(openaiMessages) {
+    return openaiMessages.map((m) => ({
+        role: m.role,
+        content: m.content || '',
+        metadata: m.tool_calls
+            ? {
+                tool_calls: m.tool_calls.map((tc) => ({
+                    id: tc.id,
+                    name: tc.function.name,
+                    arguments: tc.function.arguments,
+                })),
+            }
+            : undefined,
+    }));
+}
+/**
+ * Extract span data from OpenAI response
+ */
+function extractSpanData(response, durationMs) {
+    const span = {
+        name: 'openai.chat.completions',
+        type: 'llm',
+        durationMs,
+        model: response.model,
+        provider: 'openai',
+        promptTokens: response.usage?.prompt_tokens,
+        completionTokens: response.usage?.completion_tokens,
+        status: 'ok',
+    };
+    // Extract tool calls as children
+    const toolCalls = response.choices?.[0]?.message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+        span.children = toolCalls.map((tc) => ({
+            name: tc.function.name,
+            type: 'tool',
+            toolName: tc.function.name,
+            toolParameters: JSON.parse(tc.function.arguments),
+        }));
+    }
+    return span;
+}
+// ============================================================================
+// AUTO-INSTRUMENTATION
+// ============================================================================
+/**
+ * Auto-instrument OpenAI client
+ * Call this during SDK init to automatically trace all OpenAI calls
+ *
+ * @example
+ * ```typescript
+ * import OpenAI from 'openai';
+ * import { instrumentOpenAIClient } from '@thinkhive/sdk/instrumentation/openai';
+ *
+ * const openai = new OpenAI();
+ * instrumentOpenAIClient(openai);
+ *
+ * // All subsequent calls are automatically traced
+ * const response = await openai.chat.completions.create({ ... });
+ * ```
+ */
+function instrumentOpenAIClient(client) {
+    if (!client || !client.chat?.completions?.create) {
+        (0, config_1.debugLog)('OpenAI client not found or incompatible');
+        return;
+    }
+    const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+    client.chat.completions.create = async function (params, options) {
+        return wrapChatCompletion(() => originalCreate(params, options), {
+            model: params.model,
+            messages: params.messages,
+            temperature: params.temperature,
+            maxTokens: params.max_tokens,
+        });
+    };
+    (0, config_1.debugLog)('OpenAI client instrumented');
+}
+/**
+ * Remove instrumentation from OpenAI client
+ */
+function uninstrumentOpenAIClient(client, originalCreate) {
+    if (client?.chat?.completions) {
+        client.chat.completions.create = originalCreate;
+        (0, config_1.debugLog)('OpenAI client uninstrumented');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openai.js","sourceRoot":"","sources":["../../src/instrumentation/openai.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - OpenAI Instrumentation\n *\n * Auto-instrumentation for OpenAI API calls including:\n * - Chat completions\n * - Assistants API\n * - Tool calls\n */\n\nimport { trace, context, SpanStatusCode, type Span } from '@opentelemetry/api';\nimport { getConfig, debugLog } from '../core/config';\nimport type { ConversationMessage, SpanData } from '../core/types';\n\n// ============================================================================\n// OPENAI TRACING\n// ============================================================================\n\n/**\n * Wrap an OpenAI chat completion call with tracing\n *\n * @example\n * ```typescript\n * import OpenAI from 'openai';\n * import { wrapChatCompletion } from '@thinkhive/sdk/instrumentation/openai';\n *\n * const openai = new OpenAI();\n *\n * const result = await wrapChatCompletion(\n *   () => openai.chat.completions.create({\n *     model: 'gpt-4',\n *     messages: [{ role: 'user', content: 'Hello' }],\n *   }),\n *   {\n *     model: 'gpt-4',\n *     messages: [{ role: 'user', content: 'Hello' }],\n *   }\n * );\n * ```\n */\nexport async function wrapChatCompletion<T>(\n  fn: () => Promise<T>,\n  options: {\n    model?: string;\n    messages?: Array<{ role: string; content: string }>;\n    temperature?: number;\n    maxTokens?: number;\n  } = {}\n): Promise<T> {\n  const tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  return tracer.startActiveSpan(\n    'openai.chat.completions',\n    {\n      attributes: {\n        'openinference.span.kind': 'LLM',\n        'llm.provider': 'openai',\n        'llm.model_name': options.model,\n        'llm.temperature': options.temperature,\n        'llm.max_tokens': options.maxTokens,\n        'llm.input_messages': options.messages\n          ? JSON.stringify(options.messages).substring(0, 10000)\n          : undefined,\n      },\n    },\n    async (span) => {\n      const startTime = Date.now();\n      try {\n        const result = await fn();\n\n        // Extract response data\n        const response = result as any;\n        if (response?.choices?.[0]?.message) {\n          span.setAttribute(\n            'llm.output_messages',\n            JSON.stringify(response.choices[0].message).substring(0, 10000)\n          );\n        }\n        if (response?.usage) {\n          span.setAttribute('llm.token_count.prompt', response.usage.prompt_tokens);\n          span.setAttribute('llm.token_count.completion', response.usage.completion_tokens);\n          span.setAttribute('llm.token_count.total', response.usage.total_tokens);\n        }\n\n        span.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      } catch (error: unknown) {\n        const message = error instanceof Error ? error.message : String(error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message });\n        span.recordException(error as Error);\n        throw error;\n      } finally {\n        span.setAttribute('duration_ms', Date.now() - startTime);\n        span.end();\n      }\n    }\n  );\n}\n\n/**\n * Wrap an OpenAI Assistants API call with tracing\n *\n * @example\n * ```typescript\n * import OpenAI from 'openai';\n * import { wrapAssistantRun } from '@thinkhive/sdk/instrumentation/openai';\n *\n * const openai = new OpenAI();\n *\n * const run = await wrapAssistantRun(\n *   () => openai.beta.threads.runs.create(threadId, {\n *     assistant_id: assistantId,\n *   }),\n *   { assistantId, threadId }\n * );\n * ```\n */\nexport async function wrapAssistantRun<T>(\n  fn: () => Promise<T>,\n  options: {\n    assistantId: string;\n    threadId: string;\n    model?: string;\n  }\n): Promise<T> {\n  const tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  return tracer.startActiveSpan(\n    'openai.assistants.run',\n    {\n      attributes: {\n        'openinference.span.kind': 'AGENT',\n        'llm.provider': 'openai',\n        'llm.model_name': options.model,\n        'assistant.id': options.assistantId,\n        'assistant.thread_id': options.threadId,\n      },\n    },\n    async (span) => {\n      const startTime = Date.now();\n      try {\n        const result = await fn();\n\n        const response = result as any;\n        if (response?.status) {\n          span.setAttribute('assistant.run_status', response.status);\n        }\n        if (response?.usage) {\n          span.setAttribute('llm.token_count.prompt', response.usage.prompt_tokens);\n          span.setAttribute('llm.token_count.completion', response.usage.completion_tokens);\n        }\n\n        span.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      } catch (error: unknown) {\n        const message = error instanceof Error ? error.message : String(error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message });\n        span.recordException(error as Error);\n        throw error;\n      } finally {\n        span.setAttribute('duration_ms', Date.now() - startTime);\n        span.end();\n      }\n    }\n  );\n}\n\n/**\n * Wrap an OpenAI tool call with tracing\n *\n * @example\n * ```typescript\n * const result = await wrapToolCall(\n *   () => executeMyTool(args),\n *   {\n *     toolName: 'search_orders',\n *     toolCallId: 'call_abc123',\n *     arguments: { orderId: '12345' },\n *   }\n * );\n * ```\n */\nexport async function wrapToolCall<T>(\n  fn: () => Promise<T>,\n  options: {\n    toolName: string;\n    toolCallId?: string;\n    arguments?: Record<string, unknown>;\n  }\n): Promise<T> {\n  const tracer = trace.getTracer('thinkhive', '3.0.0');\n\n  return tracer.startActiveSpan(\n    `tool.${options.toolName}`,\n    {\n      attributes: {\n        'openinference.span.kind': 'TOOL',\n        'tool.name': options.toolName,\n        'tool.call_id': options.toolCallId,\n        'tool.parameters': options.arguments\n          ? JSON.stringify(options.arguments).substring(0, 10000)\n          : undefined,\n      },\n    },\n    async (span) => {\n      const startTime = Date.now();\n      try {\n        const result = await fn();\n        span.setAttribute('tool.output', JSON.stringify(result).substring(0, 10000));\n        span.setStatus({ code: SpanStatusCode.OK });\n        return result;\n      } catch (error: unknown) {\n        const message = error instanceof Error ? error.message : String(error);\n        span.setStatus({ code: SpanStatusCode.ERROR, message });\n        span.recordException(error as Error);\n        throw error;\n      } finally {\n        span.setAttribute('duration_ms', Date.now() - startTime);\n        span.end();\n      }\n    }\n  );\n}\n\n// ============================================================================\n// EXTRACTION HELPERS\n// ============================================================================\n\n/**\n * Extract conversation messages from OpenAI format\n */\nexport function extractConversationMessages(\n  openaiMessages: Array<{\n    role: string;\n    content: string | null;\n    tool_calls?: Array<{\n      id: string;\n      function: { name: string; arguments: string };\n    }>;\n  }>\n): ConversationMessage[] {\n  return openaiMessages.map((m) => ({\n    role: m.role as ConversationMessage['role'],\n    content: m.content || '',\n    metadata: m.tool_calls\n      ? {\n          tool_calls: m.tool_calls.map((tc) => ({\n            id: tc.id,\n            name: tc.function.name,\n            arguments: tc.function.arguments,\n          })),\n        }\n      : undefined,\n  }));\n}\n\n/**\n * Extract span data from OpenAI response\n */\nexport function extractSpanData(\n  response: {\n    model?: string;\n    usage?: {\n      prompt_tokens?: number;\n      completion_tokens?: number;\n      total_tokens?: number;\n    };\n    choices?: Array<{\n      message?: {\n        tool_calls?: Array<{\n          id: string;\n          function: { name: string; arguments: string };\n        }>;\n      };\n      finish_reason?: string;\n    }>;\n  },\n  durationMs: number\n): SpanData {\n  const span: SpanData = {\n    name: 'openai.chat.completions',\n    type: 'llm',\n    durationMs,\n    model: response.model,\n    provider: 'openai',\n    promptTokens: response.usage?.prompt_tokens,\n    completionTokens: response.usage?.completion_tokens,\n    status: 'ok',\n  };\n\n  // Extract tool calls as children\n  const toolCalls = response.choices?.[0]?.message?.tool_calls;\n  if (toolCalls && toolCalls.length > 0) {\n    span.children = toolCalls.map((tc) => ({\n      name: tc.function.name,\n      type: 'tool' as const,\n      toolName: tc.function.name,\n      toolParameters: JSON.parse(tc.function.arguments),\n    }));\n  }\n\n  return span;\n}\n\n// ============================================================================\n// AUTO-INSTRUMENTATION\n// ============================================================================\n\n/**\n * Auto-instrument OpenAI client\n * Call this during SDK init to automatically trace all OpenAI calls\n *\n * @example\n * ```typescript\n * import OpenAI from 'openai';\n * import { instrumentOpenAIClient } from '@thinkhive/sdk/instrumentation/openai';\n *\n * const openai = new OpenAI();\n * instrumentOpenAIClient(openai);\n *\n * // All subsequent calls are automatically traced\n * const response = await openai.chat.completions.create({ ... });\n * ```\n */\nexport function instrumentOpenAIClient(client: any): void {\n  if (!client || !client.chat?.completions?.create) {\n    debugLog('OpenAI client not found or incompatible');\n    return;\n  }\n\n  const originalCreate = client.chat.completions.create.bind(client.chat.completions);\n\n  client.chat.completions.create = async function (params: any, options?: any) {\n    return wrapChatCompletion(\n      () => originalCreate(params, options),\n      {\n        model: params.model,\n        messages: params.messages,\n        temperature: params.temperature,\n        maxTokens: params.max_tokens,\n      }\n    );\n  };\n\n  debugLog('OpenAI client instrumented');\n}\n\n/**\n * Remove instrumentation from OpenAI client\n */\nexport function uninstrumentOpenAIClient(client: any, originalCreate: any): void {\n  if (client?.chat?.completions) {\n    client.chat.completions.create = originalCreate;\n    debugLog('OpenAI client uninstrumented');\n  }\n}\n"]}

package/dist/integrations/customer-context.d.ts

@@ -0,0 +1,203 @@
+/**
+ * ThinkHive SDK v3.0 - Customer Context
+ *
+ * Time-series customer metrics snapshots
+ * Captures ARR, health score, segment AS OF the run time (not current values)
+ */
+import type { CustomerContextSnapshot } from '../core/types';
+export interface CustomerAccount {
+    id: string;
+    companyId: string;
+    externalId?: string;
+    externalSource?: 'salesforce' | 'hubspot' | 'zendesk' | 'intercom' | 'custom';
+    name: string;
+    domain?: string;
+    segment?: string;
+    industry?: string;
+    employeeCount?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CustomerMetricsSnapshot {
+    id: string;
+    customerAccountId: string;
+    arr?: number;
+    healthScore?: number;
+    nps?: number;
+    segment?: string;
+    churnRisk?: 'low' | 'medium' | 'high';
+    capturedAt: string;
+    source?: string;
+    createdAt: string;
+}
+/**
+ * Customer context API client for time-series metrics
+ */
+export declare const customerContext: {
+    /**
+     * Create a customer account
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.createAccount({
+     *   name: 'Acme Corp',
+     *   externalId: 'sf_001234',
+     *   externalSource: 'salesforce',
+     *   segment: 'enterprise',
+     * });
+     * ```
+     */
+    createAccount(input: {
+        name: string;
+        externalId?: string;
+        externalSource?: CustomerAccount["externalSource"];
+        domain?: string;
+        segment?: string;
+        industry?: string;
+        employeeCount?: number;
+    }): Promise<CustomerAccount>;
+    /**
+     * Get a customer account by ID
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.getAccount('cust_abc123');
+     * ```
+     */
+    getAccount(customerId: string): Promise<CustomerAccount>;
+    /**
+     * Get a customer account by external ID
+     *
+     * @example
+     * ```typescript
+     * const account = await customerContext.getAccountByExternalId(
+     *   'sf_001234',
+     *   'salesforce'
+     * );
+     * ```
+     */
+    getAccountByExternalId(externalId: string, source: CustomerAccount["externalSource"]): Promise<CustomerAccount | null>;
+    /**
+     * 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,
+     *   },
+     *   // ...
+     * });
+     * ```
+     */
+    captureSnapshot(customerId: string, metrics: {
+        arr?: number;
+        healthScore?: number;
+        nps?: number;
+        segment?: string;
+        churnRisk?: "low" | "medium" | "high";
+        source?: string;
+    }): Promise<CustomerMetricsSnapshot>;
+    /**
+     * 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(),
+     * });
+     * ```
+     */
+    getSnapshots(customerId: string, options?: {
+        from?: string;
+        to?: string;
+        limit?: number;
+    }): Promise<CustomerMetricsSnapshot[]>;
+    /**
+     * Get the most recent snapshot for a customer
+     *
+     * @example
+     * ```typescript
+     * const latest = await customerContext.getLatestSnapshot('cust_abc123');
+     * ```
+     */
+    getLatestSnapshot(customerId: string): Promise<CustomerMetricsSnapshot | null>;
+    /**
+     * 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'
+     * );
+     * ```
+     */
+    getSnapshotAsOf(customerId: string, timestamp: string | Date): Promise<CustomerMetricsSnapshot | null>;
+};
+/**
+ * Create a CustomerContextSnapshot from a metrics snapshot
+ */
+export declare function toContextSnapshot(snapshot: CustomerMetricsSnapshot): CustomerContextSnapshot;
+/**
+ * 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,
+ *   // ...
+ * });
+ * ```
+ */
+export declare function captureCustomerContext(customerId: string, metrics: {
+    arr?: number;
+    healthScore?: number;
+    segment?: string;
+}): Promise<CustomerContextSnapshot>;
+/**
+ * Get customer context as of a specific time
+ */
+export declare function getContextAsOf(customerId: string, timestamp: string | Date): Promise<CustomerContextSnapshot | null>;
+/**
+ * Calculate ARR change between two snapshots
+ */
+export declare function calculateArrChange(older: CustomerMetricsSnapshot, newer: CustomerMetricsSnapshot): {
+    absolute: number;
+    percentage: number;
+    direction: 'increase' | 'decrease' | 'stable';
+};
+/**
+ * Calculate health score trend
+ */
+export declare function calculateHealthTrend(snapshots: CustomerMetricsSnapshot[]): {
+    currentScore: number | null;
+    avgScore: number | null;
+    trend: 'improving' | 'declining' | 'stable';
+    volatility: 'low' | 'medium' | 'high';
+};