@thinkhive/sdk 4.1.0 → 4.2.0

package/dist/api/signals.d.ts

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

package/dist/api/signals.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * ThinkHive SDK - Signals API
+ *
+ * Behavioral signal management for detecting patterns in agent interactions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.signals = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// SIGNALS API CLIENT
+// ============================================================================
+/**
+ * Signals API client for managing behavioral signal detection
+ */
+exports.signals = {
+    /**
+     * List all signals with optional filters
+     *
+     * @param opts - Filter options for group, source, or enabled status
+     * @returns List of signals
+     */
+    async list(opts) {
+        const params = new URLSearchParams();
+        if (opts?.group)
+            params.set('group', opts.group);
+        if (opts?.source)
+            params.set('source', opts.source);
+        if (opts?.isEnabled !== undefined)
+            params.set('isEnabled', String(opts.isEnabled));
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Create a new behavioral signal
+     *
+     * @param name - Signal name
+     * @param group - Signal group/category
+     * @param detectionConfig - Detection configuration
+     * @param opts - Additional signal options
+     * @returns The created signal
+     */
+    async create(name, group, detectionConfig, opts) {
+        return (0, client_1.apiRequestWithData)('/signals/', {
+            method: 'POST',
+            body: { name, group, detectionConfig, ...opts },
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Update an existing signal
+     *
+     * @param id - Signal ID to update
+     * @param opts - Fields to update
+     * @returns The updated signal
+     */
+    async update(id, opts) {
+        return (0, client_1.apiRequestWithData)(`/signals/${id}`, {
+            method: 'PUT',
+            body: opts,
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Delete a signal
+     *
+     * @param id - Signal ID to delete
+     */
+    async remove(id) {
+        return (0, client_1.apiRequest)(`/signals/${id}`, {
+            method: 'DELETE',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Seed default signal definitions
+     *
+     * @returns List of seeded signals
+     */
+    async seedDefaults() {
+        return (0, client_1.apiRequestWithData)('/signals/seed', {
+            method: 'POST',
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get signal statistics
+     *
+     * @param opts - Date range and agent filter options
+     * @returns Signal statistics
+     */
+    async getStats(opts) {
+        const params = new URLSearchParams();
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/stats${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get signal trend data over time
+     *
+     * @param opts - Date range, agent, and granularity options
+     * @returns Signal trend data points
+     */
+    async getTrends(opts) {
+        const params = new URLSearchParams();
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        if (opts?.granularity)
+            params.set('granularity', opts.granularity);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/trends${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get traces that triggered a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination and filter options
+     * @returns Traces associated with the signal
+     */
+    async getTraces(id, opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        if (opts?.startDate)
+            params.set('startDate', opts.startDate);
+        if (opts?.endDate)
+            params.set('endDate', opts.endDate);
+        if (opts?.agentId)
+            params.set('agentId', opts.agentId);
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${id}/traces${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+    /**
+     * Get events for a specific signal
+     *
+     * @param id - Signal ID
+     * @param opts - Pagination options
+     * @returns Signal events
+     */
+    async getEvents(id, opts) {
+        const params = new URLSearchParams();
+        if (opts?.limit !== undefined)
+            params.set('limit', String(opts.limit));
+        if (opts?.offset !== undefined)
+            params.set('offset', String(opts.offset));
+        const query = params.toString();
+        return (0, client_1.apiRequestWithData)(`/signals/${id}/events${query ? `?${query}` : ''}`, {
+            apiVersion: 'v1',
+        });
+    },
+};
+exports.default = exports.signals;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signals.js","sourceRoot":"","sources":["../../src/api/signals.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK - Signals API\n *\n * Behavioral signal management for detecting patterns in agent interactions\n */\n\nimport { apiRequest, apiRequestWithData } from '../core/client';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/** Signal detection configuration */\nexport interface DetectionConfig {\n  type: string;\n  threshold?: number;\n  pattern?: string;\n  [key: string]: unknown;\n}\n\n/** Options for creating a signal */\nexport interface CreateSignalOptions {\n  description?: string;\n  isEnabled?: boolean;\n  severity?: string;\n}\n\n/** Options for updating a signal */\nexport interface UpdateSignalOptions {\n  name?: string;\n  group?: string;\n  description?: string;\n  detectionConfig?: DetectionConfig;\n  isEnabled?: boolean;\n  severity?: string;\n}\n\n/** Options for listing signals */\nexport interface ListSignalsOptions {\n  group?: string;\n  source?: string;\n  isEnabled?: boolean;\n}\n\n/** Options for getting signal stats */\nexport interface SignalStatsOptions {\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n}\n\n/** Options for getting signal trends */\nexport interface SignalTrendsOptions {\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n  granularity?: 'hour' | 'day' | 'week' | 'month';\n}\n\n/** Options for getting signal traces */\nexport interface SignalTracesOptions {\n  limit?: number;\n  offset?: number;\n  startDate?: string;\n  endDate?: string;\n  agentId?: string;\n}\n\n/** Options for getting signal events */\nexport interface SignalEventsOptions {\n  limit?: number;\n  offset?: number;\n}\n\n/** A behavioral signal definition */\nexport interface Signal {\n  id: string;\n  name: string;\n  group: string;\n  description?: string;\n  detectionConfig: DetectionConfig;\n  isEnabled: boolean;\n  severity?: string;\n  source?: string;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/** Signal statistics */\nexport interface SignalStats {\n  signalId: string;\n  name: string;\n  eventCount: number;\n  traceCount: number;\n  lastTriggeredAt?: string;\n}\n\n/** Signal trend data point */\nexport interface SignalTrendPoint {\n  period: string;\n  eventCount: number;\n  traceCount: number;\n}\n\n/** A signal event occurrence */\nexport interface SignalEvent {\n  id: string;\n  signalId: string;\n  traceId: string;\n  detectedAt: string;\n  metadata?: Record<string, unknown>;\n}\n\n// ============================================================================\n// SIGNALS API CLIENT\n// ============================================================================\n\n/**\n * Signals API client for managing behavioral signal detection\n */\nexport const signals = {\n  /**\n   * List all signals with optional filters\n   *\n   * @param opts - Filter options for group, source, or enabled status\n   * @returns List of signals\n   */\n  async list(opts?: ListSignalsOptions): Promise<Signal[]> {\n    const params = new URLSearchParams();\n    if (opts?.group) params.set('group', opts.group);\n    if (opts?.source) params.set('source', opts.source);\n    if (opts?.isEnabled !== undefined) params.set('isEnabled', String(opts.isEnabled));\n\n    const query = params.toString();\n    return apiRequestWithData<Signal[]>(`/signals/${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Create a new behavioral signal\n   *\n   * @param name - Signal name\n   * @param group - Signal group/category\n   * @param detectionConfig - Detection configuration\n   * @param opts - Additional signal options\n   * @returns The created signal\n   */\n  async create(\n    name: string,\n    group: string,\n    detectionConfig: DetectionConfig,\n    opts?: CreateSignalOptions\n  ): Promise<Signal> {\n    return apiRequestWithData<Signal>('/signals/', {\n      method: 'POST',\n      body: { name, group, detectionConfig, ...opts },\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Update an existing signal\n   *\n   * @param id - Signal ID to update\n   * @param opts - Fields to update\n   * @returns The updated signal\n   */\n  async update(id: string, opts: UpdateSignalOptions): Promise<Signal> {\n    return apiRequestWithData<Signal>(`/signals/${id}`, {\n      method: 'PUT',\n      body: opts,\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Delete a signal\n   *\n   * @param id - Signal ID to delete\n   */\n  async remove(id: string): Promise<void> {\n    return apiRequest<void>(`/signals/${id}`, {\n      method: 'DELETE',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Seed default signal definitions\n   *\n   * @returns List of seeded signals\n   */\n  async seedDefaults(): Promise<Signal[]> {\n    return apiRequestWithData<Signal[]>('/signals/seed', {\n      method: 'POST',\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get signal statistics\n   *\n   * @param opts - Date range and agent filter options\n   * @returns Signal statistics\n   */\n  async getStats(opts?: SignalStatsOptions): Promise<SignalStats[]> {\n    const params = new URLSearchParams();\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n\n    const query = params.toString();\n    return apiRequestWithData<SignalStats[]>(`/signals/stats${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get signal trend data over time\n   *\n   * @param opts - Date range, agent, and granularity options\n   * @returns Signal trend data points\n   */\n  async getTrends(opts?: SignalTrendsOptions): Promise<SignalTrendPoint[]> {\n    const params = new URLSearchParams();\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n    if (opts?.granularity) params.set('granularity', opts.granularity);\n\n    const query = params.toString();\n    return apiRequestWithData<SignalTrendPoint[]>(`/signals/trends${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get traces that triggered a specific signal\n   *\n   * @param id - Signal ID\n   * @param opts - Pagination and filter options\n   * @returns Traces associated with the signal\n   */\n  async getTraces(id: string, opts?: SignalTracesOptions): Promise<{\n    traces: any[];\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n  }> {\n    const params = new URLSearchParams();\n    if (opts?.limit !== undefined) params.set('limit', String(opts.limit));\n    if (opts?.offset !== undefined) params.set('offset', String(opts.offset));\n    if (opts?.startDate) params.set('startDate', opts.startDate);\n    if (opts?.endDate) params.set('endDate', opts.endDate);\n    if (opts?.agentId) params.set('agentId', opts.agentId);\n\n    const query = params.toString();\n    return apiRequestWithData(`/signals/${id}/traces${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n\n  /**\n   * Get events for a specific signal\n   *\n   * @param id - Signal ID\n   * @param opts - Pagination options\n   * @returns Signal events\n   */\n  async getEvents(id: string, opts?: SignalEventsOptions): Promise<{\n    events: SignalEvent[];\n    limit: number;\n    offset: number;\n    hasMore: boolean;\n  }> {\n    const params = new URLSearchParams();\n    if (opts?.limit !== undefined) params.set('limit', String(opts.limit));\n    if (opts?.offset !== undefined) params.set('offset', String(opts.offset));\n\n    const query = params.toString();\n    return apiRequestWithData(`/signals/${id}/events${query ? `?${query}` : ''}`, {\n      apiVersion: 'v1',\n    });\n  },\n};\n\nexport { signals as default };\n"]}

package/dist/core/client.d.ts

@@ -13,6 +13,8 @@ export interface RequestOptions {
     maxRetries?: number;
     /** Request timeout in milliseconds */
     timeout?: number;
+    /** Use path as-is without prepending /api/ prefix (for routes like /v1/guardrails/scan) */
+    rawPath?: boolean;
 }
 /**
  * Make an authenticated API request with retry logic

package/dist/core/client.js

@@ -37,9 +37,15 @@ function sleep(ms) {
  */
 async function apiRequest(path, options = {}) {
     const config = (0, config_1.getConfig)();
-    const { method = 'GET', body, headers = {}, apiVersion, maxRetries, timeout } = options;
-    const version = apiVersion === 'none' ? '' : (apiVersion || '');
-    const url = version ? `${config.endpoint}/api/${version}${path}` : `${config.endpoint}/api${path}`;
+    const { method = 'GET', body, headers = {}, apiVersion, maxRetries, timeout, rawPath } = options;
+    let url;
+    if (rawPath) {
+        url = `${config.endpoint}${path}`;
+    }
+    else {
+        const version = apiVersion === 'none' ? '' : (apiVersion || '');
+        url = version ? `${config.endpoint}/api/${version}${path}` : `${config.endpoint}/api${path}`;
+    }
     const retries = maxRetries ?? MAX_RETRIES;
     const requestTimeout = timeout ?? 30000; // Default 30s
     const requestHeaders = {
@@ -281,4 +287,4 @@ class IpWhitelistError extends ThinkHiveError {
     }
 }
 exports.IpWhitelistError = IpWhitelistError;
-//# 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, SDK_VERSION } from './config';\nimport type { ApiResponse } from './types';\n\n// ============================================================================\n// RETRY CONFIGURATION\n// ============================================================================\n\nconst MAX_RETRIES = 3;\nconst INITIAL_BACKOFF = 500; // ms\nconst MAX_BACKOFF = 8000; // ms\nconst RETRYABLE_CODES = new Set([408, 429, 500, 502, 503, 504]);\n\n/**\n * Calculate backoff time for retry attempt\n */\nfunction calculateBackoff(attempt: number, retryAfter?: number): number {\n  if (retryAfter !== undefined) {\n    return Math.min(retryAfter * 1000, MAX_BACKOFF); // Convert seconds to ms\n  }\n  const backoff = INITIAL_BACKOFF * Math.pow(2, attempt);\n  return Math.min(backoff, MAX_BACKOFF);\n}\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n// ============================================================================\n// HTTP CLIENT\n// ============================================================================\n\nexport interface RequestOptions {\n  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n  body?: unknown;\n  headers?: Record<string, string>;\n  /** Override API version for this request. Use 'none' for unversioned routes (e.g., /api/agents). */\n  apiVersion?: 'v1' | 'v2' | 'v3' | 'none';\n  /** Override max retries for this request */\n  maxRetries?: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Make an authenticated API request with retry logic\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, maxRetries, timeout } = options;\n\n  const version = apiVersion === 'none' ? '' : (apiVersion || '');\n  const url = version ? `${config.endpoint}/api/${version}${path}` : `${config.endpoint}/api${path}`;\n  const retries = maxRetries ?? MAX_RETRIES;\n  const requestTimeout = timeout ?? 30000; // Default 30s\n\n  const requestHeaders: Record<string, string> = {\n    'Content-Type': 'application/json',\n    'X-SDK-Version': SDK_VERSION,\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  let lastError: Error | null = null;\n\n  for (let attempt = 0; attempt <= retries; attempt++) {\n    try {\n      // Create abort controller for timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), requestTimeout);\n\n      let response: Response;\n      try {\n        response = await fetch(url, {\n          method,\n          headers: requestHeaders,\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n      } finally {\n        clearTimeout(timeoutId);\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      // Check if response is retryable\n      if (RETRYABLE_CODES.has(response.status) && attempt < retries) {\n        // Get Retry-After header if present (for 429 responses)\n        let retryAfter: number | undefined;\n        if (response.status === 429) {\n          const retryAfterHeader = response.headers.get('Retry-After');\n          if (retryAfterHeader) {\n            retryAfter = parseFloat(retryAfterHeader);\n            if (isNaN(retryAfter)) {\n              retryAfter = undefined;\n            }\n          }\n        }\n\n        const backoff = calculateBackoff(attempt, retryAfter);\n        debugLog(`Retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n        await sleep(backoff);\n        continue;\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        // Handle rate limit specifically\n        if (response.status === 429) {\n          const retryAfterHeader = response.headers.get('Retry-After');\n          const retryAfter = retryAfterHeader ? parseFloat(retryAfterHeader) * 1000 : 60000;\n          throw new RateLimitError(retryAfter);\n        }\n\n        throw new ThinkHiveApiError(\n          errorData.message || `HTTP ${response.status}`,\n          response.status,\n          errorData.code\n        );\n      }\n\n      // Handle 204 No Content (e.g., successful DELETE)\n      if (response.status === 204) {\n        return undefined as unknown as T;\n      }\n\n      return response.json() as Promise<T>;\n    } catch (error) {\n      // Handle abort (timeout)\n      if (error instanceof Error && error.name === 'AbortError') {\n        lastError = new ThinkHiveApiError(`Request timed out after ${requestTimeout}ms`, 408);\n        if (attempt < retries) {\n          const backoff = calculateBackoff(attempt);\n          debugLog(`Request timed out, retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n          await sleep(backoff);\n          continue;\n        }\n        throw lastError;\n      }\n\n      // Handle network errors (TypeError from fetch)\n      if (error instanceof TypeError) {\n        lastError = new ThinkHiveApiError(`Network error: ${error.message}`, 503);\n        if (attempt < retries) {\n          const backoff = calculateBackoff(attempt);\n          debugLog(`Network error, retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n          await sleep(backoff);\n          continue;\n        }\n        throw lastError;\n      }\n\n      // Re-throw ThinkHive errors (non-retryable)\n      if (error instanceof ThinkHiveError) {\n        throw error;\n      }\n\n      // Unknown error\n      lastError = error instanceof Error ? error : new Error(String(error));\n      if (attempt < retries) {\n        const backoff = calculateBackoff(attempt);\n        await sleep(backoff);\n        continue;\n      }\n      throw new ThinkHiveApiError(`Request failed: ${lastError.message}`, 500);\n    }\n  }\n\n  // Should not reach here, but just in case\n  throw lastError || new ThinkHiveApiError('Request failed after all retries', 500);\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\n/**\n * Base error class for ThinkHive SDK errors\n */\nexport class ThinkHiveError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly statusCode?: number,\n    public readonly details?: Record<string, unknown>\n  ) {\n    super(message);\n    this.name = 'ThinkHiveError';\n  }\n}\n\n/**\n * API request error - returned from ThinkHive server\n */\nexport class ThinkHiveApiError extends ThinkHiveError {\n  constructor(\n    message: string,\n    statusCode: number,\n    code?: string\n  ) {\n    super(message, code || 'API_ERROR', statusCode);\n    this.name = 'ThinkHiveApiError';\n  }\n}\n\n/**\n * Validation error - invalid input parameters\n */\nexport class ThinkHiveValidationError extends ThinkHiveError {\n  constructor(\n    message: string,\n    public readonly field?: string\n  ) {\n    super(message, 'VALIDATION_ERROR', 400, field ? { field } : undefined);\n    this.name = 'ThinkHiveValidationError';\n  }\n}\n\n/**\n * Permission denied error - API key lacks required permissions\n * @example\n * ```typescript\n * try {\n *   await thinkHive.traces.create(...);\n * } catch (error) {\n *   if (error instanceof PermissionDeniedError) {\n *     console.log('API key needs write permission');\n *   }\n * }\n * ```\n */\nexport class PermissionDeniedError extends ThinkHiveError {\n  constructor(message: string, details?: Record<string, unknown>) {\n    super(message, 'PERMISSION_DENIED', 403, details);\n    this.name = 'PermissionDeniedError';\n  }\n}\n\n/**\n * Agent scope violation error - API key not authorized for this agent\n * @example\n * ```typescript\n * // Create key scoped to specific agents\n * const key = await thinkHive.apiKeys.create({\n *   name: 'Agent A Key',\n *   allowedAgentIds: ['agent-a-id']\n * });\n *\n * // Attempting to use for Agent B will throw AgentScopeError\n * ```\n */\nexport class AgentScopeError extends ThinkHiveError {\n  constructor(\n    agentId: string,\n    allowedAgents: string[]\n  ) {\n    super(\n      `API key not authorized for agent ${agentId}`,\n      'AGENT_SCOPE_VIOLATION',\n      403,\n      { agentId, allowedAgents }\n    );\n    this.name = 'AgentScopeError';\n  }\n}\n\n/**\n * Rate limit exceeded error\n * @example\n * ```typescript\n * try {\n *   await thinkHive.traces.create(...);\n * } catch (error) {\n *   if (error instanceof RateLimitError) {\n *     // Wait and retry\n *     await sleep(error.retryAfter);\n *     await thinkHive.traces.create(...);\n *   }\n * }\n * ```\n */\nexport class RateLimitError extends ThinkHiveError {\n  constructor(\n    public readonly retryAfter: number\n  ) {\n    super(\n      `Rate limit exceeded. Retry after ${retryAfter}ms`,\n      'RATE_LIMIT_EXCEEDED',\n      429,\n      { retryAfter }\n    );\n    this.name = 'RateLimitError';\n  }\n}\n\n/**\n * IP whitelist violation error\n */\nexport class IpWhitelistError extends ThinkHiveError {\n  constructor(clientIp: string) {\n    super(\n      'Request IP address is not authorized for this API key',\n      'IP_WHITELIST_VIOLATION',\n      403,\n      { clientIp }\n    );\n    this.name = 'IpWhitelistError';\n  }\n}\n"]}
+//# 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, SDK_VERSION } from './config';\nimport type { ApiResponse } from './types';\n\n// ============================================================================\n// RETRY CONFIGURATION\n// ============================================================================\n\nconst MAX_RETRIES = 3;\nconst INITIAL_BACKOFF = 500; // ms\nconst MAX_BACKOFF = 8000; // ms\nconst RETRYABLE_CODES = new Set([408, 429, 500, 502, 503, 504]);\n\n/**\n * Calculate backoff time for retry attempt\n */\nfunction calculateBackoff(attempt: number, retryAfter?: number): number {\n  if (retryAfter !== undefined) {\n    return Math.min(retryAfter * 1000, MAX_BACKOFF); // Convert seconds to ms\n  }\n  const backoff = INITIAL_BACKOFF * Math.pow(2, attempt);\n  return Math.min(backoff, MAX_BACKOFF);\n}\n\n/**\n * Sleep for a given number of milliseconds\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n// ============================================================================\n// HTTP CLIENT\n// ============================================================================\n\nexport interface RequestOptions {\n  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';\n  body?: unknown;\n  headers?: Record<string, string>;\n  /** Override API version for this request. Use 'none' for unversioned routes (e.g., /api/agents). */\n  apiVersion?: 'v1' | 'v2' | 'v3' | 'none';\n  /** Override max retries for this request */\n  maxRetries?: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n  /** Use path as-is without prepending /api/ prefix (for routes like /v1/guardrails/scan) */\n  rawPath?: boolean;\n}\n\n/**\n * Make an authenticated API request with retry logic\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, maxRetries, timeout, rawPath } = options;\n\n  let url: string;\n  if (rawPath) {\n    url = `${config.endpoint}${path}`;\n  } else {\n    const version = apiVersion === 'none' ? '' : (apiVersion || '');\n    url = version ? `${config.endpoint}/api/${version}${path}` : `${config.endpoint}/api${path}`;\n  }\n  const retries = maxRetries ?? MAX_RETRIES;\n  const requestTimeout = timeout ?? 30000; // Default 30s\n\n  const requestHeaders: Record<string, string> = {\n    'Content-Type': 'application/json',\n    'X-SDK-Version': SDK_VERSION,\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  let lastError: Error | null = null;\n\n  for (let attempt = 0; attempt <= retries; attempt++) {\n    try {\n      // Create abort controller for timeout\n      const controller = new AbortController();\n      const timeoutId = setTimeout(() => controller.abort(), requestTimeout);\n\n      let response: Response;\n      try {\n        response = await fetch(url, {\n          method,\n          headers: requestHeaders,\n          body: body ? JSON.stringify(body) : undefined,\n          signal: controller.signal,\n        });\n      } finally {\n        clearTimeout(timeoutId);\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      // Check if response is retryable\n      if (RETRYABLE_CODES.has(response.status) && attempt < retries) {\n        // Get Retry-After header if present (for 429 responses)\n        let retryAfter: number | undefined;\n        if (response.status === 429) {\n          const retryAfterHeader = response.headers.get('Retry-After');\n          if (retryAfterHeader) {\n            retryAfter = parseFloat(retryAfterHeader);\n            if (isNaN(retryAfter)) {\n              retryAfter = undefined;\n            }\n          }\n        }\n\n        const backoff = calculateBackoff(attempt, retryAfter);\n        debugLog(`Retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n        await sleep(backoff);\n        continue;\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        // Handle rate limit specifically\n        if (response.status === 429) {\n          const retryAfterHeader = response.headers.get('Retry-After');\n          const retryAfter = retryAfterHeader ? parseFloat(retryAfterHeader) * 1000 : 60000;\n          throw new RateLimitError(retryAfter);\n        }\n\n        throw new ThinkHiveApiError(\n          errorData.message || `HTTP ${response.status}`,\n          response.status,\n          errorData.code\n        );\n      }\n\n      // Handle 204 No Content (e.g., successful DELETE)\n      if (response.status === 204) {\n        return undefined as unknown as T;\n      }\n\n      return response.json() as Promise<T>;\n    } catch (error) {\n      // Handle abort (timeout)\n      if (error instanceof Error && error.name === 'AbortError') {\n        lastError = new ThinkHiveApiError(`Request timed out after ${requestTimeout}ms`, 408);\n        if (attempt < retries) {\n          const backoff = calculateBackoff(attempt);\n          debugLog(`Request timed out, retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n          await sleep(backoff);\n          continue;\n        }\n        throw lastError;\n      }\n\n      // Handle network errors (TypeError from fetch)\n      if (error instanceof TypeError) {\n        lastError = new ThinkHiveApiError(`Network error: ${error.message}`, 503);\n        if (attempt < retries) {\n          const backoff = calculateBackoff(attempt);\n          debugLog(`Network error, retrying after ${backoff}ms (attempt ${attempt + 1}/${retries})`);\n          await sleep(backoff);\n          continue;\n        }\n        throw lastError;\n      }\n\n      // Re-throw ThinkHive errors (non-retryable)\n      if (error instanceof ThinkHiveError) {\n        throw error;\n      }\n\n      // Unknown error\n      lastError = error instanceof Error ? error : new Error(String(error));\n      if (attempt < retries) {\n        const backoff = calculateBackoff(attempt);\n        await sleep(backoff);\n        continue;\n      }\n      throw new ThinkHiveApiError(`Request failed: ${lastError.message}`, 500);\n    }\n  }\n\n  // Should not reach here, but just in case\n  throw lastError || new ThinkHiveApiError('Request failed after all retries', 500);\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\n/**\n * Base error class for ThinkHive SDK errors\n */\nexport class ThinkHiveError extends Error {\n  constructor(\n    message: string,\n    public readonly code: string,\n    public readonly statusCode?: number,\n    public readonly details?: Record<string, unknown>\n  ) {\n    super(message);\n    this.name = 'ThinkHiveError';\n  }\n}\n\n/**\n * API request error - returned from ThinkHive server\n */\nexport class ThinkHiveApiError extends ThinkHiveError {\n  constructor(\n    message: string,\n    statusCode: number,\n    code?: string\n  ) {\n    super(message, code || 'API_ERROR', statusCode);\n    this.name = 'ThinkHiveApiError';\n  }\n}\n\n/**\n * Validation error - invalid input parameters\n */\nexport class ThinkHiveValidationError extends ThinkHiveError {\n  constructor(\n    message: string,\n    public readonly field?: string\n  ) {\n    super(message, 'VALIDATION_ERROR', 400, field ? { field } : undefined);\n    this.name = 'ThinkHiveValidationError';\n  }\n}\n\n/**\n * Permission denied error - API key lacks required permissions\n * @example\n * ```typescript\n * try {\n *   await thinkHive.traces.create(...);\n * } catch (error) {\n *   if (error instanceof PermissionDeniedError) {\n *     console.log('API key needs write permission');\n *   }\n * }\n * ```\n */\nexport class PermissionDeniedError extends ThinkHiveError {\n  constructor(message: string, details?: Record<string, unknown>) {\n    super(message, 'PERMISSION_DENIED', 403, details);\n    this.name = 'PermissionDeniedError';\n  }\n}\n\n/**\n * Agent scope violation error - API key not authorized for this agent\n * @example\n * ```typescript\n * // Create key scoped to specific agents\n * const key = await thinkHive.apiKeys.create({\n *   name: 'Agent A Key',\n *   allowedAgentIds: ['agent-a-id']\n * });\n *\n * // Attempting to use for Agent B will throw AgentScopeError\n * ```\n */\nexport class AgentScopeError extends ThinkHiveError {\n  constructor(\n    agentId: string,\n    allowedAgents: string[]\n  ) {\n    super(\n      `API key not authorized for agent ${agentId}`,\n      'AGENT_SCOPE_VIOLATION',\n      403,\n      { agentId, allowedAgents }\n    );\n    this.name = 'AgentScopeError';\n  }\n}\n\n/**\n * Rate limit exceeded error\n * @example\n * ```typescript\n * try {\n *   await thinkHive.traces.create(...);\n * } catch (error) {\n *   if (error instanceof RateLimitError) {\n *     // Wait and retry\n *     await sleep(error.retryAfter);\n *     await thinkHive.traces.create(...);\n *   }\n * }\n * ```\n */\nexport class RateLimitError extends ThinkHiveError {\n  constructor(\n    public readonly retryAfter: number\n  ) {\n    super(\n      `Rate limit exceeded. Retry after ${retryAfter}ms`,\n      'RATE_LIMIT_EXCEEDED',\n      429,\n      { retryAfter }\n    );\n    this.name = 'RateLimitError';\n  }\n}\n\n/**\n * IP whitelist violation error\n */\nexport class IpWhitelistError extends ThinkHiveError {\n  constructor(clientIp: string) {\n    super(\n      'Request IP address is not authorized for this API key',\n      'IP_WHITELIST_VIOLATION',\n      403,\n      { clientIp }\n    );\n    this.name = 'IpWhitelistError';\n  }\n}\n"]}

package/dist/guardrails.d.ts

@@ -0,0 +1,70 @@
+/**
+ * ThinkHive Guardrails SDK Module
+ * Real-time content scanning using centralized SDK configuration
+ */
+export interface ScanRequest {
+    input?: string;
+    output?: string;
+    toolCall?: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+    scanners?: string[];
+    policyId?: string;
+    config?: Record<string, Record<string, unknown>>;
+    options?: {
+        timeout?: number;
+        failOpen?: boolean;
+        shortCircuit?: boolean;
+        returnRedacted?: boolean;
+    };
+}
+export interface Finding {
+    type: string;
+    value: string;
+    start: number;
+    end: number;
+    confidence: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ScannerResult {
+    scanner: string;
+    status: 'completed' | 'timeout' | 'error';
+    action: 'pass' | 'block' | 'redact' | 'flag';
+    findings: Finding[];
+    latencyMs: number;
+    sanitizedContent?: string;
+}
+export interface ScanResponse {
+    action: 'pass' | 'block' | 'redact' | 'flag';
+    actionReason?: string;
+    redactedInput?: string;
+    redactedOutput?: string;
+    results: Record<string, ScannerResult>;
+    metadata: {
+        scanId: string;
+        totalLatencyMs: number;
+        scannersExecuted: number;
+        scannersBlocked: number;
+        scannersFlagged: number;
+        scannersTimedOut: number;
+        cached: boolean;
+    };
+}
+/**
+ * Guardrails API client
+ * Real-time content scanning for PII, secrets, keywords, and more
+ */
+export declare const guardrails: {
+    /**
+     * Scan content for policy violations
+     */
+    scan(request: ScanRequest): Promise<ScanResponse>;
+    /**
+     * List available scanners
+     */
+    listScanners(): Promise<Array<{
+        name: string;
+        description: string;
+    }>>;
+};

package/dist/guardrails.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * ThinkHive Guardrails SDK Module
+ * Real-time content scanning using centralized SDK configuration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guardrails = void 0;
+const client_1 = require("./core/client");
+/**
+ * Guardrails API client
+ * Real-time content scanning for PII, secrets, keywords, and more
+ */
+exports.guardrails = {
+    /**
+     * Scan content for policy violations
+     */
+    async scan(request) {
+        return (0, client_1.apiRequestWithData)('/v1/guardrails/scan', {
+            method: 'POST',
+            body: request,
+            rawPath: true,
+        });
+    },
+    /**
+     * List available scanners
+     */
+    async listScanners() {
+        const result = await (0, client_1.apiRequestWithData)('/v1/guardrails/scanners', {
+            rawPath: true,
+        });
+        return result.scanners;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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