@thinkhive/sdk 2.0.0 → 3.0.0

package/dist/api/runs.d.ts

@@ -0,0 +1,200 @@
+/**
+ * ThinkHive SDK v3.0 - Runs API
+ *
+ * Run-centric API for creating and managing runs (the atomic unit in v3)
+ */
+import type { RunOptions, RunResponse, CustomerContextSnapshot, ConversationMessage, RunOutcome } from '../core/types';
+/**
+ * List runs query options
+ */
+export interface ListRunsOptions {
+    agentId?: string;
+    ticketId?: string;
+    customerAccountId?: string;
+    outcome?: RunOutcome;
+    startedAfter?: string | Date;
+    startedBefore?: string | Date;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Run stats response
+ */
+export interface RunStats {
+    agentId: string;
+    period: {
+        from: string;
+        to: string;
+    };
+    totalRuns: number;
+    outcomeBreakdown: Record<RunOutcome, number>;
+    avgDurationMs: number;
+    linkedTickets: number;
+    unlinkedRuns: number;
+}
+/**
+ * Runs API client for v3 run-centric operations
+ */
+export declare const runs: {
+    /**
+     * Create a new run
+     *
+     * @example
+     * ```typescript
+     * const run = await runs.create({
+     *   agentId: 'agent_123',
+     *   conversationMessages: [
+     *     { role: 'user', content: 'Help me with my order' },
+     *     { role: 'assistant', content: 'I can help with that...' },
+     *   ],
+     *   outcome: 'resolved',
+     *   customerContext: {
+     *     arr: 50000,
+     *     healthScore: 85,
+     *     segment: 'enterprise',
+     *   },
+     * });
+     * ```
+     */
+    create(options: RunOptions): Promise<RunResponse>;
+    /**
+     * Get a run by ID
+     *
+     * @example
+     * ```typescript
+     * const run = await runs.get('run_abc123');
+     * ```
+     */
+    get(runId: string): Promise<RunResponse>;
+    /**
+     * List runs with filters
+     *
+     * @example
+     * ```typescript
+     * const { items, hasMore } = await runs.list({
+     *   agentId: 'agent_123',
+     *   outcome: 'failed',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    list(options?: ListRunsOptions): Promise<{
+        items: RunResponse[];
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Update a run
+     *
+     * @example
+     * ```typescript
+     * await runs.update('run_abc123', {
+     *   outcome: 'resolved',
+     *   outcomeReason: 'Customer confirmed issue resolved',
+     * });
+     * ```
+     */
+    update(runId: string, updates: Partial<Pick<RunOptions, "outcome" | "outcomeReason" | "endedAt" | "metadata">>): Promise<RunResponse>;
+    /**
+     * Delete a run
+     *
+     * @example
+     * ```typescript
+     * await runs.delete('run_abc123');
+     * ```
+     */
+    delete(runId: string): Promise<void>;
+    /**
+     * Create multiple runs in batch
+     *
+     * @example
+     * ```typescript
+     * const { created, failed } = await runs.batch([
+     *   { agentId: 'agent_1', conversationMessages: [...] },
+     *   { agentId: 'agent_1', conversationMessages: [...] },
+     * ]);
+     * ```
+     */
+    batch(runsData: RunOptions[]): Promise<{
+        created: RunResponse[];
+        failed: Array<{
+            index: number;
+            error: string;
+        }>;
+    }>;
+    /**
+     * Get run statistics for an agent
+     *
+     * @example
+     * ```typescript
+     * const stats = await runs.stats('agent_123', {
+     *   from: '2024-01-01',
+     *   to: '2024-01-31',
+     * });
+     * ```
+     */
+    stats(agentId: string, options?: {
+        from?: string | Date;
+        to?: string | Date;
+    }): Promise<RunStats>;
+    /**
+     * Get traces for a run
+     *
+     * @example
+     * ```typescript
+     * const traces = await runs.getTraces('run_abc123');
+     * ```
+     */
+    getTraces(runId: string): Promise<unknown[]>;
+    /**
+     * Add a trace to a run
+     *
+     * @example
+     * ```typescript
+     * await runs.addTrace('run_abc123', {
+     *   spans: [...],
+     *   timestamp: new Date().toISOString(),
+     * });
+     * ```
+     */
+    addTrace(runId: string, traceData: {
+        spans?: unknown[];
+        timestamp?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        traceId: string;
+    }>;
+};
+/**
+ * Create a run with customer context snapshot
+ *
+ * @example
+ * ```typescript
+ * const run = await createRunWithContext({
+ *   agentId: 'agent_123',
+ *   conversationMessages: [...],
+ *   customerContext: {
+ *     arr: 100000,
+ *     healthScore: 92,
+ *   },
+ * });
+ * ```
+ */
+export declare function createRunWithContext(options: RunOptions & {
+    customerContext: CustomerContextSnapshot;
+}): Promise<RunResponse>;
+/**
+ * Convert conversation messages to OpenAI format
+ */
+export declare function toOpenAIMessages(messages: ConversationMessage[]): Array<{
+    role: string;
+    content: string;
+}>;
+/**
+ * Convert OpenAI format messages to ThinkHive format
+ */
+export declare function fromOpenAIMessages(messages: Array<{
+    role: string;
+    content: string;
+}>): ConversationMessage[];

package/dist/api/runs.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - Runs API
+ *
+ * Run-centric API for creating and managing runs (the atomic unit in v3)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runs = void 0;
+exports.createRunWithContext = createRunWithContext;
+exports.toOpenAIMessages = toOpenAIMessages;
+exports.fromOpenAIMessages = fromOpenAIMessages;
+const client_1 = require("../core/client");
+/**
+ * Runs API client for v3 run-centric operations
+ */
+exports.runs = {
+    /**
+     * Create a new run
+     *
+     * @example
+     * ```typescript
+     * const run = await runs.create({
+     *   agentId: 'agent_123',
+     *   conversationMessages: [
+     *     { role: 'user', content: 'Help me with my order' },
+     *     { role: 'assistant', content: 'I can help with that...' },
+     *   ],
+     *   outcome: 'resolved',
+     *   customerContext: {
+     *     arr: 50000,
+     *     healthScore: 85,
+     *     segment: 'enterprise',
+     *   },
+     * });
+     * ```
+     */
+    async create(options) {
+        const startedAt = options.startedAt
+            ? new Date(options.startedAt).toISOString()
+            : new Date().toISOString();
+        const payload = {
+            agentId: options.agentId,
+            startedAt,
+            endedAt: options.endedAt
+                ? new Date(options.endedAt).toISOString()
+                : undefined,
+            outcome: options.outcome,
+            outcomeReason: options.outcomeReason,
+            conversationMessages: options.conversationMessages,
+            modelId: options.modelId,
+            promptVersion: options.promptVersion,
+            sessionId: options.sessionId,
+            customerContext: options.customerContext,
+            metadata: options.metadata,
+        };
+        return (0, client_1.apiRequestWithData)('/runs', {
+            method: 'POST',
+            body: payload,
+        });
+    },
+    /**
+     * Get a run by ID
+     *
+     * @example
+     * ```typescript
+     * const run = await runs.get('run_abc123');
+     * ```
+     */
+    async get(runId) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}`);
+    },
+    /**
+     * List runs with filters
+     *
+     * @example
+     * ```typescript
+     * const { items, hasMore } = await runs.list({
+     *   agentId: 'agent_123',
+     *   outcome: 'failed',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    async list(options = {}) {
+        const params = new URLSearchParams();
+        if (options.agentId)
+            params.set('agentId', options.agentId);
+        if (options.ticketId)
+            params.set('ticketId', options.ticketId);
+        if (options.customerAccountId)
+            params.set('customerAccountId', options.customerAccountId);
+        if (options.outcome)
+            params.set('outcome', options.outcome);
+        if (options.startedAfter) {
+            params.set('startedAfter', new Date(options.startedAfter).toISOString());
+        }
+        if (options.startedBefore) {
+            params.set('startedBefore', new Date(options.startedBefore).toISOString());
+        }
+        if (options.limit)
+            params.set('limit', String(options.limit));
+        if (options.offset)
+            params.set('offset', String(options.offset));
+        const response = await (0, client_1.apiRequest)(`/runs?${params.toString()}`);
+        return response.data;
+    },
+    /**
+     * Update a run
+     *
+     * @example
+     * ```typescript
+     * await runs.update('run_abc123', {
+     *   outcome: 'resolved',
+     *   outcomeReason: 'Customer confirmed issue resolved',
+     * });
+     * ```
+     */
+    async update(runId, updates) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}`, {
+            method: 'PUT',
+            body: updates,
+        });
+    },
+    /**
+     * Delete a run
+     *
+     * @example
+     * ```typescript
+     * await runs.delete('run_abc123');
+     * ```
+     */
+    async delete(runId) {
+        await (0, client_1.apiRequest)(`/runs/${runId}`, { method: 'DELETE' });
+    },
+    /**
+     * Create multiple runs in batch
+     *
+     * @example
+     * ```typescript
+     * const { created, failed } = await runs.batch([
+     *   { agentId: 'agent_1', conversationMessages: [...] },
+     *   { agentId: 'agent_1', conversationMessages: [...] },
+     * ]);
+     * ```
+     */
+    async batch(runsData) {
+        const payload = runsData.map((r) => ({
+            agentId: r.agentId,
+            startedAt: r.startedAt
+                ? new Date(r.startedAt).toISOString()
+                : new Date().toISOString(),
+            endedAt: r.endedAt ? new Date(r.endedAt).toISOString() : undefined,
+            outcome: r.outcome,
+            outcomeReason: r.outcomeReason,
+            conversationMessages: r.conversationMessages,
+            modelId: r.modelId,
+            promptVersion: r.promptVersion,
+            sessionId: r.sessionId,
+            customerContext: r.customerContext,
+            metadata: r.metadata,
+        }));
+        return (0, client_1.apiRequestWithData)('/runs/batch', {
+            method: 'POST',
+            body: { runs: payload },
+        });
+    },
+    /**
+     * Get run statistics for an agent
+     *
+     * @example
+     * ```typescript
+     * const stats = await runs.stats('agent_123', {
+     *   from: '2024-01-01',
+     *   to: '2024-01-31',
+     * });
+     * ```
+     */
+    async stats(agentId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.from)
+            params.set('from', new Date(options.from).toISOString());
+        if (options.to)
+            params.set('to', new Date(options.to).toISOString());
+        return (0, client_1.apiRequestWithData)(`/runs/stats/${agentId}?${params.toString()}`);
+    },
+    /**
+     * Get traces for a run
+     *
+     * @example
+     * ```typescript
+     * const traces = await runs.getTraces('run_abc123');
+     * ```
+     */
+    async getTraces(runId) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}/traces`);
+    },
+    /**
+     * Add a trace to a run
+     *
+     * @example
+     * ```typescript
+     * await runs.addTrace('run_abc123', {
+     *   spans: [...],
+     *   timestamp: new Date().toISOString(),
+     * });
+     * ```
+     */
+    async addTrace(runId, traceData) {
+        return (0, client_1.apiRequestWithData)(`/runs/${runId}/traces`, {
+            method: 'POST',
+            body: traceData,
+        });
+    },
+};
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Create a run with customer context snapshot
+ *
+ * @example
+ * ```typescript
+ * const run = await createRunWithContext({
+ *   agentId: 'agent_123',
+ *   conversationMessages: [...],
+ *   customerContext: {
+ *     arr: 100000,
+ *     healthScore: 92,
+ *   },
+ * });
+ * ```
+ */
+async function createRunWithContext(options) {
+    // Ensure capturedAt is set
+    const customerContext = {
+        ...options.customerContext,
+        capturedAt: options.customerContext.capturedAt || new Date().toISOString(),
+    };
+    return exports.runs.create({
+        ...options,
+        customerContext,
+    });
+}
+/**
+ * Convert conversation messages to OpenAI format
+ */
+function toOpenAIMessages(messages) {
+    return messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    }));
+}
+/**
+ * Convert OpenAI format messages to ThinkHive format
+ */
+function fromOpenAIMessages(messages) {
+    return messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runs.js","sourceRoot":"","sources":["../../src/api/runs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - Runs API\n *\n * Run-centric API for creating and managing runs (the atomic unit in v3)\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\nimport type {\n  RunOptions,\n  RunResponse,\n  ApiResponse,\n  PaginatedResponse,\n  CustomerContextSnapshot,\n  ConversationMessage,\n  RunOutcome,\n} from '../core/types';\n\n// ============================================================================\n// RUNS API CLIENT\n// ============================================================================\n\n/**\n * List runs query options\n */\nexport interface ListRunsOptions {\n  agentId?: string;\n  ticketId?: string;\n  customerAccountId?: string;\n  outcome?: RunOutcome;\n  startedAfter?: string | Date;\n  startedBefore?: string | Date;\n  limit?: number;\n  offset?: number;\n}\n\n/**\n * Run stats response\n */\nexport interface RunStats {\n  agentId: string;\n  period: { from: string; to: string };\n  totalRuns: number;\n  outcomeBreakdown: Record<RunOutcome, number>;\n  avgDurationMs: number;\n  linkedTickets: number;\n  unlinkedRuns: number;\n}\n\n/**\n * Runs API client for v3 run-centric operations\n */\nexport const runs = {\n  /**\n   * Create a new run\n   *\n   * @example\n   * ```typescript\n   * const run = await runs.create({\n   *   agentId: 'agent_123',\n   *   conversationMessages: [\n   *     { role: 'user', content: 'Help me with my order' },\n   *     { role: 'assistant', content: 'I can help with that...' },\n   *   ],\n   *   outcome: 'resolved',\n   *   customerContext: {\n   *     arr: 50000,\n   *     healthScore: 85,\n   *     segment: 'enterprise',\n   *   },\n   * });\n   * ```\n   */\n  async create(options: RunOptions): Promise<RunResponse> {\n    const startedAt = options.startedAt\n      ? new Date(options.startedAt).toISOString()\n      : new Date().toISOString();\n\n    const payload = {\n      agentId: options.agentId,\n      startedAt,\n      endedAt: options.endedAt\n        ? new Date(options.endedAt).toISOString()\n        : undefined,\n      outcome: options.outcome,\n      outcomeReason: options.outcomeReason,\n      conversationMessages: options.conversationMessages,\n      modelId: options.modelId,\n      promptVersion: options.promptVersion,\n      sessionId: options.sessionId,\n      customerContext: options.customerContext,\n      metadata: options.metadata,\n    };\n\n    return apiRequestWithData<RunResponse>('/runs', {\n      method: 'POST',\n      body: payload,\n    });\n  },\n\n  /**\n   * Get a run by ID\n   *\n   * @example\n   * ```typescript\n   * const run = await runs.get('run_abc123');\n   * ```\n   */\n  async get(runId: string): Promise<RunResponse> {\n    return apiRequestWithData<RunResponse>(`/runs/${runId}`);\n  },\n\n  /**\n   * List runs with filters\n   *\n   * @example\n   * ```typescript\n   * const { items, hasMore } = await runs.list({\n   *   agentId: 'agent_123',\n   *   outcome: 'failed',\n   *   limit: 20,\n   * });\n   * ```\n   */\n  async list(\n    options: ListRunsOptions = {}\n  ): Promise<{ items: RunResponse[]; limit: number; offset: number; hasMore: boolean }> {\n    const params = new URLSearchParams();\n    if (options.agentId) params.set('agentId', options.agentId);\n    if (options.ticketId) params.set('ticketId', options.ticketId);\n    if (options.customerAccountId) params.set('customerAccountId', options.customerAccountId);\n    if (options.outcome) params.set('outcome', options.outcome);\n    if (options.startedAfter) {\n      params.set('startedAfter', new Date(options.startedAfter).toISOString());\n    }\n    if (options.startedBefore) {\n      params.set('startedBefore', new Date(options.startedBefore).toISOString());\n    }\n    if (options.limit) params.set('limit', String(options.limit));\n    if (options.offset) params.set('offset', String(options.offset));\n\n    const response = await apiRequest<PaginatedResponse<RunResponse>>(\n      `/runs?${params.toString()}`\n    );\n    return response.data;\n  },\n\n  /**\n   * Update a run\n   *\n   * @example\n   * ```typescript\n   * await runs.update('run_abc123', {\n   *   outcome: 'resolved',\n   *   outcomeReason: 'Customer confirmed issue resolved',\n   * });\n   * ```\n   */\n  async update(\n    runId: string,\n    updates: Partial<Pick<RunOptions, 'outcome' | 'outcomeReason' | 'endedAt' | 'metadata'>>\n  ): Promise<RunResponse> {\n    return apiRequestWithData<RunResponse>(`/runs/${runId}`, {\n      method: 'PUT',\n      body: updates,\n    });\n  },\n\n  /**\n   * Delete a run\n   *\n   * @example\n   * ```typescript\n   * await runs.delete('run_abc123');\n   * ```\n   */\n  async delete(runId: string): Promise<void> {\n    await apiRequest(`/runs/${runId}`, { method: 'DELETE' });\n  },\n\n  /**\n   * Create multiple runs in batch\n   *\n   * @example\n   * ```typescript\n   * const { created, failed } = await runs.batch([\n   *   { agentId: 'agent_1', conversationMessages: [...] },\n   *   { agentId: 'agent_1', conversationMessages: [...] },\n   * ]);\n   * ```\n   */\n  async batch(\n    runsData: RunOptions[]\n  ): Promise<{ created: RunResponse[]; failed: Array<{ index: number; error: string }> }> {\n    const payload = runsData.map((r) => ({\n      agentId: r.agentId,\n      startedAt: r.startedAt\n        ? new Date(r.startedAt).toISOString()\n        : new Date().toISOString(),\n      endedAt: r.endedAt ? new Date(r.endedAt).toISOString() : undefined,\n      outcome: r.outcome,\n      outcomeReason: r.outcomeReason,\n      conversationMessages: r.conversationMessages,\n      modelId: r.modelId,\n      promptVersion: r.promptVersion,\n      sessionId: r.sessionId,\n      customerContext: r.customerContext,\n      metadata: r.metadata,\n    }));\n\n    return apiRequestWithData('/runs/batch', {\n      method: 'POST',\n      body: { runs: payload },\n    });\n  },\n\n  /**\n   * Get run statistics for an agent\n   *\n   * @example\n   * ```typescript\n   * const stats = await runs.stats('agent_123', {\n   *   from: '2024-01-01',\n   *   to: '2024-01-31',\n   * });\n   * ```\n   */\n  async stats(\n    agentId: string,\n    options: { from?: string | Date; to?: string | Date } = {}\n  ): Promise<RunStats> {\n    const params = new URLSearchParams();\n    if (options.from) params.set('from', new Date(options.from).toISOString());\n    if (options.to) params.set('to', new Date(options.to).toISOString());\n\n    return apiRequestWithData<RunStats>(\n      `/runs/stats/${agentId}?${params.toString()}`\n    );\n  },\n\n  /**\n   * Get traces for a run\n   *\n   * @example\n   * ```typescript\n   * const traces = await runs.getTraces('run_abc123');\n   * ```\n   */\n  async getTraces(runId: string): Promise<unknown[]> {\n    return apiRequestWithData<unknown[]>(`/runs/${runId}/traces`);\n  },\n\n  /**\n   * Add a trace to a run\n   *\n   * @example\n   * ```typescript\n   * await runs.addTrace('run_abc123', {\n   *   spans: [...],\n   *   timestamp: new Date().toISOString(),\n   * });\n   * ```\n   */\n  async addTrace(\n    runId: string,\n    traceData: { spans?: unknown[]; timestamp?: string; metadata?: Record<string, unknown> }\n  ): Promise<{ traceId: string }> {\n    return apiRequestWithData(`/runs/${runId}/traces`, {\n      method: 'POST',\n      body: traceData,\n    });\n  },\n};\n\n// ============================================================================\n// HELPER FUNCTIONS\n// ============================================================================\n\n/**\n * Create a run with customer context snapshot\n *\n * @example\n * ```typescript\n * const run = await createRunWithContext({\n *   agentId: 'agent_123',\n *   conversationMessages: [...],\n *   customerContext: {\n *     arr: 100000,\n *     healthScore: 92,\n *   },\n * });\n * ```\n */\nexport async function createRunWithContext(\n  options: RunOptions & { customerContext: CustomerContextSnapshot }\n): Promise<RunResponse> {\n  // Ensure capturedAt is set\n  const customerContext: CustomerContextSnapshot = {\n    ...options.customerContext,\n    capturedAt: options.customerContext.capturedAt || new Date().toISOString(),\n  };\n\n  return runs.create({\n    ...options,\n    customerContext,\n  });\n}\n\n/**\n * Convert conversation messages to OpenAI format\n */\nexport function toOpenAIMessages(\n  messages: ConversationMessage[]\n): Array<{ role: string; content: string }> {\n  return messages.map((m) => ({\n    role: m.role,\n    content: m.content,\n  }));\n}\n\n/**\n * Convert OpenAI format messages to ThinkHive format\n */\nexport function fromOpenAIMessages(\n  messages: Array<{ role: string; content: string }>\n): ConversationMessage[] {\n  return messages.map((m) => ({\n    role: m.role as ConversationMessage['role'],\n    content: m.content,\n  }));\n}\n"]}

package/dist/core/client.d.ts

@@ -0,0 +1,29 @@
+/**
+ * ThinkHive SDK v3.0 - HTTP Client
+ *
+ * Centralized HTTP client with authentication and error handling
+ */
+export interface RequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    body?: unknown;
+    headers?: Record<string, string>;
+    /** Override API version for this request */
+    apiVersion?: 'v1' | 'v3';
+}
+/**
+ * Make an authenticated API request
+ */
+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);
+}
+export declare class ThinkHiveValidationError extends Error {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}

package/dist/core/client.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * ThinkHive SDK v3.0 - HTTP Client
+ *
+ * Centralized HTTP client with authentication and error handling
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThinkHiveValidationError = exports.ThinkHiveApiError = void 0;
+exports.apiRequest = apiRequest;
+exports.apiRequestWithData = apiRequestWithData;
+const config_1 = require("./config");
+/**
+ * Make an authenticated API request
+ */
+async function apiRequest(path, options = {}) {
+    const config = (0, config_1.getConfig)();
+    const { method = 'GET', body, headers = {}, apiVersion } = options;
+    const version = apiVersion || config.apiVersion;
+    const url = `${config.endpoint}/api/${version}${path}`;
+    const requestHeaders = {
+        'Content-Type': 'application/json',
+        'X-SDK-Version': '3.0.0',
+        ...headers,
+    };
+    if (config.apiKey) {
+        requestHeaders['Authorization'] = `Bearer ${config.apiKey}`;
+    }
+    else if (config.agentId) {
+        requestHeaders['X-Agent-ID'] = config.agentId;
+    }
+    (0, config_1.debugLog)(`${method} ${url}`);
+    const response = await fetch(url, {
+        method,
+        headers: requestHeaders,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    // Handle deprecation warnings
+    if (response.headers.has('Deprecation')) {
+        const sunset = response.headers.get('Sunset');
+        const link = response.headers.get('Link');
+        console.warn(`[ThinkHive] Deprecation warning: This endpoint is deprecated.` +
+            (sunset ? ` Sunset: ${sunset}` : '') +
+            (link ? ` Successor: ${link}` : ''));
+    }
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData = {};
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { message: errorText };
+        }
+        const error = new ThinkHiveApiError(errorData.message || `HTTP ${response.status}`, response.status, errorData.code);
+        throw error;
+    }
+    return response.json();
+}
+/**
+ * Make an API request and extract data from response wrapper
+ */
+async function apiRequestWithData(path, options = {}) {
+    const response = await apiRequest(path, options);
+    if (!response.success) {
+        throw new ThinkHiveApiError(response.error?.message || 'Unknown error', 500, response.error?.code);
+    }
+    return response.data;
+}
+// ============================================================================
+// ERRORS
+// ============================================================================
+class ThinkHiveApiError extends Error {
+    constructor(message, statusCode, code) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'ThinkHiveApiError';
+    }
+}
+exports.ThinkHiveApiError = ThinkHiveApiError;
+class ThinkHiveValidationError extends Error {
+    constructor(message, field) {
+        super(message);
+        this.field = field;
+        this.name = 'ThinkHiveValidationError';
+    }
+}
+exports.ThinkHiveValidationError = ThinkHiveValidationError;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/core/client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK v3.0 - HTTP Client\n *\n * Centralized HTTP client with authentication and error handling\n */\n\nimport { getConfig, debugLog } from './config';\nimport type { ApiResponse } from './types';\n\n// ============================================================================\n// HTTP CLIENT\n// ============================================================================\n\nexport interface RequestOptions {\n  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';\n  body?: unknown;\n  headers?: Record<string, string>;\n  /** Override API version for this request */\n  apiVersion?: 'v1' | 'v3';\n}\n\n/**\n * Make an authenticated API request\n */\nexport async function apiRequest<T>(\n  path: string,\n  options: RequestOptions = {}\n): Promise<T> {\n  const config = getConfig();\n  const { method = 'GET', body, headers = {}, apiVersion } = options;\n\n  const version = apiVersion || config.apiVersion;\n  const url = `${config.endpoint}/api/${version}${path}`;\n\n  const requestHeaders: Record<string, string> = {\n    'Content-Type': 'application/json',\n    'X-SDK-Version': '3.0.0',\n    ...headers,\n  };\n\n  if (config.apiKey) {\n    requestHeaders['Authorization'] = `Bearer ${config.apiKey}`;\n  } else if (config.agentId) {\n    requestHeaders['X-Agent-ID'] = config.agentId;\n  }\n\n  debugLog(`${method} ${url}`);\n\n  const response = await fetch(url, {\n    method,\n    headers: requestHeaders,\n    body: body ? JSON.stringify(body) : undefined,\n  });\n\n  // Handle deprecation warnings\n  if (response.headers.has('Deprecation')) {\n    const sunset = response.headers.get('Sunset');\n    const link = response.headers.get('Link');\n    console.warn(\n      `[ThinkHive] Deprecation warning: This endpoint is deprecated.` +\n        (sunset ? ` Sunset: ${sunset}` : '') +\n        (link ? ` Successor: ${link}` : '')\n    );\n  }\n\n  if (!response.ok) {\n    const errorText = await response.text();\n    let errorData: { message?: string; code?: string } = {};\n    try {\n      errorData = JSON.parse(errorText);\n    } catch {\n      errorData = { message: errorText };\n    }\n\n    const error = new ThinkHiveApiError(\n      errorData.message || `HTTP ${response.status}`,\n      response.status,\n      errorData.code\n    );\n    throw error;\n  }\n\n  return response.json() as Promise<T>;\n}\n\n/**\n * Make an API request and extract data from response wrapper\n */\nexport async function apiRequestWithData<T>(\n  path: string,\n  options: RequestOptions = {}\n): Promise<T> {\n  const response = await apiRequest<ApiResponse<T>>(path, options);\n  if (!response.success) {\n    throw new ThinkHiveApiError(\n      response.error?.message || 'Unknown error',\n      500,\n      response.error?.code\n    );\n  }\n  return response.data as T;\n}\n\n// ============================================================================\n// ERRORS\n// ============================================================================\n\nexport class ThinkHiveApiError extends Error {\n  constructor(\n    message: string,\n    public readonly statusCode: number,\n    public readonly code?: string\n  ) {\n    super(message);\n    this.name = 'ThinkHiveApiError';\n  }\n}\n\nexport class ThinkHiveValidationError extends Error {\n  constructor(\n    message: string,\n    public readonly field?: string\n  ) {\n    super(message);\n    this.name = 'ThinkHiveValidationError';\n  }\n}\n"]}

package/dist/core/config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * ThinkHive SDK v3.0 - Configuration
+ */
+import type { InitOptions, Framework } from './types';
+export declare const SDK_VERSION = "3.0.0";
+export declare const DEFAULT_ENDPOINT = "https://thinkhivemind-h25z7pvd3q-uc.a.run.app";
+export declare const DEFAULT_SERVICE_NAME = "my-ai-agent";
+export interface ResolvedConfig {
+    apiKey: string;
+    agentId: string;
+    endpoint: string;
+    serviceName: string;
+    autoInstrument: boolean;
+    frameworks: Framework[];
+    debug: boolean;
+    apiVersion: 'v1' | 'v3';
+}
+/**
+ * Initialize configuration from options
+ */
+export declare function initConfig(options?: InitOptions): ResolvedConfig;
+/**
+ * Get current configuration
+ * @throws if not initialized
+ */
+export declare function getConfig(): ResolvedConfig;
+/**
+ * Check if SDK is initialized
+ */
+export declare function isInitialized(): boolean;
+/**
+ * Reset configuration (for testing)
+ */
+export declare function resetConfig(): void;
+/**
+ * Debug log helper
+ */
+export declare function debugLog(...args: unknown[]): void;