@thinkhive/sdk 3.1.1 → 4.0.0

package/dist/api/agents.d.ts

@@ -0,0 +1,169 @@
+/**
+ * ThinkHive SDK - Agents Management
+ *
+ * CRUD operations for managing AI agents:
+ * - List, get, create, update, delete agents
+ * - Agent configuration management
+ *
+ * @example
+ * ```typescript
+ * import { agents } from 'thinkhive-js';
+ *
+ * // List all agents
+ * const allAgents = await agents.list();
+ *
+ * // Create a new agent
+ * const agent = await agents.create({
+ *   name: 'Support Agent',
+ *   description: 'Handles customer support',
+ *   agentType: 'customer_support',
+ *   primarySuccessMetric: 'Deflection Rate',
+ * });
+ *
+ * // Update an agent
+ * await agents.update(agent.id, { name: 'Updated Agent' });
+ *
+ * // Get agent configuration
+ * const config = await agents.getConfig(agent.id);
+ *
+ * // Delete an agent (with dry-run preview)
+ * const impact = await agents.delete(agent.id, { dryRun: true });
+ * console.log(`Will delete ${impact.cascadeImpact.traces} traces`);
+ *
+ * // Actually delete
+ * await agents.delete(agent.id);
+ * ```
+ */
+export interface Agent {
+    id: string;
+    companyId: string;
+    departmentId?: string | null;
+    createdBy?: string | null;
+    name: string;
+    description: string;
+    industry: string;
+    successMetrics: string[];
+    agentType?: string | null;
+    agentOwner?: string | null;
+    builtInHouse?: boolean | null;
+    primarySuccessMetric?: string | null;
+    secondaryMetrics?: string[] | null;
+    connectedSystem?: string | null;
+    telemetryMethod?: string | null;
+    autoEvaluate?: boolean | null;
+    evaluationSampleRate?: string | null;
+    defaultCriteriaIds?: string[] | null;
+    defaultGuardrailIds?: string[] | null;
+    createdAt?: string | null;
+}
+export interface CreateAgentOptions {
+    name: string;
+    description?: string;
+    industry?: string;
+    agentType?: string;
+    agentOwner?: string;
+    builtInHouse?: boolean;
+    departmentId?: string;
+    successMetrics?: string[];
+    primarySuccessMetric?: string;
+    secondaryMetrics?: string[];
+    connectedSystem?: string;
+    autoEvaluate?: boolean;
+    evaluationSampleRate?: number;
+}
+export interface UpdateAgentOptions {
+    name?: string;
+    description?: string;
+    agentType?: string;
+    agentOwner?: string;
+    builtInHouse?: boolean;
+    departmentId?: string | null;
+    industry?: string;
+    primarySuccessMetric?: string;
+    secondaryMetrics?: string[];
+    connectedSystem?: string;
+    autoEvaluate?: boolean;
+    evaluationSampleRate?: number;
+    isActive?: boolean;
+}
+export interface AgentConfig {
+    id: string;
+    agentId: string;
+    version: number;
+    name: string;
+    description?: string | null;
+    provider: string;
+    model: string;
+    temperature?: string | null;
+    maxTokens?: number | null;
+    systemPrompt?: string | null;
+    promptTemplate?: string | null;
+    ragEnabled?: boolean | null;
+    ragConfig?: unknown;
+    toolsEnabled?: boolean | null;
+    tools?: unknown;
+    isBaseline?: boolean | null;
+    isActive?: boolean | null;
+    createdAt?: string | null;
+    updatedAt?: string | null;
+}
+export interface UpdateAgentConfigOptions {
+    name?: string;
+    provider?: string;
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    systemPrompt?: string;
+    promptTemplate?: string;
+    ragEnabled?: boolean;
+    ragConfig?: Record<string, unknown>;
+    toolsEnabled?: boolean;
+    tools?: unknown[];
+}
+export interface DeleteAgentOptions {
+    /** If true, returns cascade impact without actually deleting */
+    dryRun?: boolean;
+}
+export interface CascadeImpact {
+    dryRun: boolean;
+    agentId: string;
+    agentName: string;
+    cascadeImpact: {
+        traces: number;
+        apiKeys: number;
+        runningEvaluations?: number;
+    };
+}
+export declare const agents: {
+    /**
+     * List agents for the authenticated company
+     */
+    list(options?: {
+        companyId?: string;
+        departmentId?: string;
+    }): Promise<Agent[]>;
+    /**
+     * Get a single agent by ID
+     */
+    get(id: string): Promise<Agent>;
+    /**
+     * Create a new agent
+     */
+    create(options: CreateAgentOptions): Promise<Agent>;
+    /**
+     * Update an existing agent
+     */
+    update(id: string, options: UpdateAgentOptions): Promise<Agent>;
+    /**
+     * Delete an agent. Use dryRun option to preview cascade impact.
+     */
+    delete(id: string, options?: DeleteAgentOptions): Promise<void | CascadeImpact>;
+    /**
+     * Get agent configuration (baseline)
+     */
+    getConfig(agentId: string): Promise<AgentConfig | null>;
+    /**
+     * Create or update agent configuration
+     */
+    updateConfig(agentId: string, config: UpdateAgentConfigOptions): Promise<AgentConfig>;
+};

package/dist/api/agents.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * ThinkHive SDK - Agents Management
+ *
+ * CRUD operations for managing AI agents:
+ * - List, get, create, update, delete agents
+ * - Agent configuration management
+ *
+ * @example
+ * ```typescript
+ * import { agents } from 'thinkhive-js';
+ *
+ * // List all agents
+ * const allAgents = await agents.list();
+ *
+ * // Create a new agent
+ * const agent = await agents.create({
+ *   name: 'Support Agent',
+ *   description: 'Handles customer support',
+ *   agentType: 'customer_support',
+ *   primarySuccessMetric: 'Deflection Rate',
+ * });
+ *
+ * // Update an agent
+ * await agents.update(agent.id, { name: 'Updated Agent' });
+ *
+ * // Get agent configuration
+ * const config = await agents.getConfig(agent.id);
+ *
+ * // Delete an agent (with dry-run preview)
+ * const impact = await agents.delete(agent.id, { dryRun: true });
+ * console.log(`Will delete ${impact.cascadeImpact.traces} traces`);
+ *
+ * // Actually delete
+ * await agents.delete(agent.id);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agents = void 0;
+const client_1 = require("../core/client");
+// ============================================================================
+// API Client
+// ============================================================================
+exports.agents = {
+    /**
+     * List agents for the authenticated company
+     */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.companyId)
+            params.set('companyId', options.companyId);
+        if (options?.departmentId)
+            params.set('departmentId', options.departmentId);
+        const qs = params.toString();
+        const response = await (0, client_1.apiRequest)(`/agents${qs ? `?${qs}` : ''}`, { apiVersion: 'none' });
+        return response.data ?? response;
+    },
+    /**
+     * Get a single agent by ID
+     */
+    async get(id) {
+        if (!id)
+            throw new client_1.ThinkHiveValidationError('Agent ID is required', 'id');
+        const response = await (0, client_1.apiRequest)(`/agents/${id}`, { apiVersion: 'none' });
+        return response.data ?? response;
+    },
+    /**
+     * Create a new agent
+     */
+    async create(options) {
+        if (!options.name) {
+            throw new client_1.ThinkHiveValidationError('Agent name is required', 'name');
+        }
+        const body = {
+            name: options.name,
+            description: options.description || '',
+            industry: options.industry || 'other',
+            successMetrics: options.successMetrics ?? [options.primarySuccessMetric || 'Task Success Rate'],
+        };
+        if (options.agentType)
+            body.agentType = options.agentType;
+        if (options.agentOwner)
+            body.agentOwner = options.agentOwner;
+        if (options.builtInHouse !== undefined)
+            body.builtInHouse = options.builtInHouse;
+        if (options.departmentId)
+            body.departmentId = options.departmentId;
+        if (options.primarySuccessMetric)
+            body.primarySuccessMetric = options.primarySuccessMetric;
+        if (options.secondaryMetrics)
+            body.secondaryMetrics = options.secondaryMetrics;
+        if (options.connectedSystem)
+            body.connectedSystem = options.connectedSystem;
+        if (options.autoEvaluate !== undefined)
+            body.autoEvaluate = options.autoEvaluate;
+        if (options.evaluationSampleRate !== undefined) {
+            body.evaluationSampleRate = options.evaluationSampleRate.toFixed(4);
+        }
+        const response = await (0, client_1.apiRequest)('/agents', {
+            method: 'POST',
+            body,
+            apiVersion: 'none',
+        });
+        return response.data ?? response;
+    },
+    /**
+     * Update an existing agent
+     */
+    async update(id, options) {
+        if (!id)
+            throw new client_1.ThinkHiveValidationError('Agent ID is required', 'id');
+        const body = {};
+        if (options.name !== undefined)
+            body.name = options.name;
+        if (options.description !== undefined)
+            body.description = options.description;
+        if (options.agentType !== undefined)
+            body.agentType = options.agentType;
+        if (options.agentOwner !== undefined)
+            body.agentOwner = options.agentOwner;
+        if (options.builtInHouse !== undefined)
+            body.builtInHouse = options.builtInHouse;
+        if (options.departmentId !== undefined)
+            body.departmentId = options.departmentId;
+        if (options.industry !== undefined)
+            body.industry = options.industry;
+        if (options.primarySuccessMetric !== undefined)
+            body.primarySuccessMetric = options.primarySuccessMetric;
+        if (options.secondaryMetrics !== undefined)
+            body.secondaryMetrics = options.secondaryMetrics;
+        if (options.connectedSystem !== undefined)
+            body.connectedSystem = options.connectedSystem;
+        if (options.autoEvaluate !== undefined)
+            body.autoEvaluate = options.autoEvaluate;
+        if (options.isActive !== undefined)
+            body.isActive = options.isActive;
+        if (options.evaluationSampleRate !== undefined) {
+            body.evaluationSampleRate = options.evaluationSampleRate.toFixed(4);
+        }
+        const response = await (0, client_1.apiRequest)(`/agents/${id}`, {
+            method: 'PATCH',
+            body,
+            apiVersion: 'none',
+        });
+        return response.data ?? response;
+    },
+    /**
+     * Delete an agent. Use dryRun option to preview cascade impact.
+     */
+    async delete(id, options) {
+        if (!id)
+            throw new client_1.ThinkHiveValidationError('Agent ID is required', 'id');
+        const qs = options?.dryRun ? '?dryRun=true' : '';
+        const response = await (0, client_1.apiRequest)(`/agents/${id}${qs}`, {
+            method: 'DELETE',
+            apiVersion: 'none',
+        });
+        if (options?.dryRun) {
+            return response.data ?? response;
+        }
+    },
+    /**
+     * Get agent configuration (baseline)
+     */
+    async getConfig(agentId) {
+        if (!agentId)
+            throw new client_1.ThinkHiveValidationError('Agent ID is required', 'agentId');
+        const response = await (0, client_1.apiRequest)(`/agents/${agentId}/config`, { apiVersion: 'none' });
+        return response?.data ?? response ?? null;
+    },
+    /**
+     * Create or update agent configuration
+     */
+    async updateConfig(agentId, config) {
+        if (!agentId)
+            throw new client_1.ThinkHiveValidationError('Agent ID is required', 'agentId');
+        const response = await (0, client_1.apiRequest)(`/agents/${agentId}/config`, {
+            method: 'PUT',
+            body: config,
+            apiVersion: 'none',
+        });
+        return response.data ?? response;
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"agents.js","sourceRoot":"","sources":["../../src/api/agents.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ThinkHive SDK - Agents Management\n *\n * CRUD operations for managing AI agents:\n * - List, get, create, update, delete agents\n * - Agent configuration management\n *\n * @example\n * ```typescript\n * import { agents } from 'thinkhive-js';\n *\n * // List all agents\n * const allAgents = await agents.list();\n *\n * // Create a new agent\n * const agent = await agents.create({\n *   name: 'Support Agent',\n *   description: 'Handles customer support',\n *   agentType: 'customer_support',\n *   primarySuccessMetric: 'Deflection Rate',\n * });\n *\n * // Update an agent\n * await agents.update(agent.id, { name: 'Updated Agent' });\n *\n * // Get agent configuration\n * const config = await agents.getConfig(agent.id);\n *\n * // Delete an agent (with dry-run preview)\n * const impact = await agents.delete(agent.id, { dryRun: true });\n * console.log(`Will delete ${impact.cascadeImpact.traces} traces`);\n *\n * // Actually delete\n * await agents.delete(agent.id);\n * ```\n */\n\nimport { apiRequest, ThinkHiveValidationError } from '../core/client';\n\n// ============================================================================\n// Types\n// ============================================================================\n\nexport interface Agent {\n  id: string;\n  companyId: string;\n  departmentId?: string | null;\n  createdBy?: string | null;\n  name: string;\n  description: string;\n  industry: string;\n  successMetrics: string[];\n  agentType?: string | null;\n  agentOwner?: string | null;\n  builtInHouse?: boolean | null;\n  primarySuccessMetric?: string | null;\n  secondaryMetrics?: string[] | null;\n  connectedSystem?: string | null;\n  telemetryMethod?: string | null;\n  autoEvaluate?: boolean | null;\n  evaluationSampleRate?: string | null;\n  defaultCriteriaIds?: string[] | null;\n  defaultGuardrailIds?: string[] | null;\n  createdAt?: string | null;\n}\n\nexport interface CreateAgentOptions {\n  name: string;\n  description?: string;\n  industry?: string;\n  agentType?: string;\n  agentOwner?: string;\n  builtInHouse?: boolean;\n  departmentId?: string;\n  successMetrics?: string[];\n  primarySuccessMetric?: string;\n  secondaryMetrics?: string[];\n  connectedSystem?: string;\n  autoEvaluate?: boolean;\n  evaluationSampleRate?: number;\n}\n\nexport interface UpdateAgentOptions {\n  name?: string;\n  description?: string;\n  agentType?: string;\n  agentOwner?: string;\n  builtInHouse?: boolean;\n  departmentId?: string | null;\n  industry?: string;\n  primarySuccessMetric?: string;\n  secondaryMetrics?: string[];\n  connectedSystem?: string;\n  autoEvaluate?: boolean;\n  evaluationSampleRate?: number;\n  isActive?: boolean;\n}\n\nexport interface AgentConfig {\n  id: string;\n  agentId: string;\n  version: number;\n  name: string;\n  description?: string | null;\n  provider: string;\n  model: string;\n  temperature?: string | null;\n  maxTokens?: number | null;\n  systemPrompt?: string | null;\n  promptTemplate?: string | null;\n  ragEnabled?: boolean | null;\n  ragConfig?: unknown;\n  toolsEnabled?: boolean | null;\n  tools?: unknown;\n  isBaseline?: boolean | null;\n  isActive?: boolean | null;\n  createdAt?: string | null;\n  updatedAt?: string | null;\n}\n\nexport interface UpdateAgentConfigOptions {\n  name?: string;\n  provider?: string;\n  model?: string;\n  temperature?: number;\n  maxTokens?: number;\n  systemPrompt?: string;\n  promptTemplate?: string;\n  ragEnabled?: boolean;\n  ragConfig?: Record<string, unknown>;\n  toolsEnabled?: boolean;\n  tools?: unknown[];\n}\n\nexport interface DeleteAgentOptions {\n  /** If true, returns cascade impact without actually deleting */\n  dryRun?: boolean;\n}\n\nexport interface CascadeImpact {\n  dryRun: boolean;\n  agentId: string;\n  agentName: string;\n  cascadeImpact: {\n    traces: number;\n    apiKeys: number;\n    runningEvaluations?: number;\n  };\n}\n\n// ============================================================================\n// API Client\n// ============================================================================\n\nexport const agents = {\n  /**\n   * List agents for the authenticated company\n   */\n  async list(options?: {\n    companyId?: string;\n    departmentId?: string;\n  }): Promise<Agent[]> {\n    const params = new URLSearchParams();\n    if (options?.companyId) params.set('companyId', options.companyId);\n    if (options?.departmentId) params.set('departmentId', options.departmentId);\n\n    const qs = params.toString();\n    const response = await apiRequest(`/agents${qs ? `?${qs}` : ''}`, { apiVersion: 'none' });\n    return (response as any).data ?? response;\n  },\n\n  /**\n   * Get a single agent by ID\n   */\n  async get(id: string): Promise<Agent> {\n    if (!id) throw new ThinkHiveValidationError('Agent ID is required', 'id');\n    const response = await apiRequest(`/agents/${id}`, { apiVersion: 'none' });\n    return (response as any).data ?? response;\n  },\n\n  /**\n   * Create a new agent\n   */\n  async create(options: CreateAgentOptions): Promise<Agent> {\n    if (!options.name) {\n      throw new ThinkHiveValidationError('Agent name is required', 'name');\n    }\n\n    const body: Record<string, unknown> = {\n      name: options.name,\n      description: options.description || '',\n      industry: options.industry || 'other',\n      successMetrics: options.successMetrics ?? [options.primarySuccessMetric || 'Task Success Rate'],\n    };\n\n    if (options.agentType) body.agentType = options.agentType;\n    if (options.agentOwner) body.agentOwner = options.agentOwner;\n    if (options.builtInHouse !== undefined) body.builtInHouse = options.builtInHouse;\n    if (options.departmentId) body.departmentId = options.departmentId;\n    if (options.primarySuccessMetric) body.primarySuccessMetric = options.primarySuccessMetric;\n    if (options.secondaryMetrics) body.secondaryMetrics = options.secondaryMetrics;\n    if (options.connectedSystem) body.connectedSystem = options.connectedSystem;\n    if (options.autoEvaluate !== undefined) body.autoEvaluate = options.autoEvaluate;\n    if (options.evaluationSampleRate !== undefined) {\n      body.evaluationSampleRate = options.evaluationSampleRate.toFixed(4);\n    }\n\n    const response = await apiRequest('/agents', {\n      method: 'POST',\n      body,\n      apiVersion: 'none',\n    });\n    return (response as any).data ?? response;\n  },\n\n  /**\n   * Update an existing agent\n   */\n  async update(id: string, options: UpdateAgentOptions): Promise<Agent> {\n    if (!id) throw new ThinkHiveValidationError('Agent ID is required', 'id');\n\n    const body: Record<string, unknown> = {};\n    if (options.name !== undefined) body.name = options.name;\n    if (options.description !== undefined) body.description = options.description;\n    if (options.agentType !== undefined) body.agentType = options.agentType;\n    if (options.agentOwner !== undefined) body.agentOwner = options.agentOwner;\n    if (options.builtInHouse !== undefined) body.builtInHouse = options.builtInHouse;\n    if (options.departmentId !== undefined) body.departmentId = options.departmentId;\n    if (options.industry !== undefined) body.industry = options.industry;\n    if (options.primarySuccessMetric !== undefined) body.primarySuccessMetric = options.primarySuccessMetric;\n    if (options.secondaryMetrics !== undefined) body.secondaryMetrics = options.secondaryMetrics;\n    if (options.connectedSystem !== undefined) body.connectedSystem = options.connectedSystem;\n    if (options.autoEvaluate !== undefined) body.autoEvaluate = options.autoEvaluate;\n    if (options.isActive !== undefined) body.isActive = options.isActive;\n    if (options.evaluationSampleRate !== undefined) {\n      body.evaluationSampleRate = options.evaluationSampleRate.toFixed(4);\n    }\n\n    const response = await apiRequest(`/agents/${id}`, {\n      method: 'PATCH',\n      body,\n      apiVersion: 'none',\n    });\n    return (response as any).data ?? response;\n  },\n\n  /**\n   * Delete an agent. Use dryRun option to preview cascade impact.\n   */\n  async delete(id: string, options?: DeleteAgentOptions): Promise<void | CascadeImpact> {\n    if (!id) throw new ThinkHiveValidationError('Agent ID is required', 'id');\n\n    const qs = options?.dryRun ? '?dryRun=true' : '';\n    const response = await apiRequest(`/agents/${id}${qs}`, {\n      method: 'DELETE',\n      apiVersion: 'none',\n    });\n\n    if (options?.dryRun) {\n      return (response as any).data ?? response;\n    }\n  },\n\n  /**\n   * Get agent configuration (baseline)\n   */\n  async getConfig(agentId: string): Promise<AgentConfig | null> {\n    if (!agentId) throw new ThinkHiveValidationError('Agent ID is required', 'agentId');\n\n    const response = await apiRequest(`/agents/${agentId}/config`, { apiVersion: 'none' });\n    return (response as any)?.data ?? response ?? null;\n  },\n\n  /**\n   * Create or update agent configuration\n   */\n  async updateConfig(agentId: string, config: UpdateAgentConfigOptions): Promise<AgentConfig> {\n    if (!agentId) throw new ThinkHiveValidationError('Agent ID is required', 'agentId');\n\n    const response = await apiRequest(`/agents/${agentId}/config`, {\n      method: 'PUT',\n      body: config,\n      apiVersion: 'none',\n    });\n    return (response as any).data ?? response;\n  },\n};\n"]}

package/dist/api/apiKeys.d.ts

@@ -0,0 +1,252 @@
+/**
+ * ThinkHive SDK - API Keys Management
+ *
+ * Create and manage scoped API keys with:
+ * - Permission control (read/write/delete)
+ * - Agent-level scoping (allowedAgentIds)
+ * - Environment separation (production/staging/development)
+ * - IP whitelisting (allowedIps)
+ *
+ * @example
+ * ```typescript
+ * import { apiKeys } from 'thinkhive-js';
+ *
+ * // Create a read-only key for monitoring
+ * const readOnlyKey = await apiKeys.create({
+ *   name: 'Monitoring Key',
+ *   scopeType: 'readonly'
+ * });
+ *
+ * // Create a key scoped to specific agents
+ * const agentKey = await apiKeys.create({
+ *   name: 'Agent A Key',
+ *   allowedAgentIds: ['agent-a-id', 'agent-b-id'],
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Create a staging environment key
+ * const stagingKey = await apiKeys.create({
+ *   name: 'Staging Key',
+ *   environment: 'staging',
+ *   allowedIps: ['10.0.0.1', '10.0.0.2']
+ * });
+ * ```
+ */
+/**
+ * API key permission configuration
+ */
+export interface ApiKeyPermissions {
+    /** Allow read operations (GET requests, listing, etc.) */
+    read: boolean;
+    /** Allow write operations (POST, PUT requests) */
+    write: boolean;
+    /** Allow delete operations (DELETE requests) */
+    delete: boolean;
+}
+/**
+ * API key scope type
+ * - `company`: Full access to all company data
+ * - `agent`: Limited to specific agents (requires allowedAgentIds)
+ * - `readonly`: Read-only access regardless of other settings
+ */
+export type ScopeType = 'company' | 'agent' | 'readonly';
+/**
+ * API key environment
+ * - `production`: For production systems
+ * - `staging`: For staging/pre-production
+ * - `development`: For local development
+ */
+export type Environment = 'production' | 'staging' | 'development';
+/**
+ * Options for creating an API key
+ */
+export interface CreateApiKeyOptions {
+    /** Display name for the key */
+    name: string;
+    /** Permission configuration (defaults to read+write) */
+    permissions?: Partial<ApiKeyPermissions>;
+    /**
+     * Restrict key to specific agent IDs
+     * When set, key can only access traces for these agents
+     */
+    allowedAgentIds?: string[];
+    /**
+     * Scope type for the key
+     * @default 'company' or 'agent' if allowedAgentIds is set
+     */
+    scopeType?: ScopeType;
+    /**
+     * Environment for the key
+     * @default 'production'
+     */
+    environment?: Environment;
+    /**
+     * Restrict key to specific IP addresses
+     * When set, only requests from these IPs can use this key
+     */
+    allowedIps?: string[];
+    /** Expiration date for the key */
+    expiresAt?: Date;
+}
+/**
+ * API key metadata (returned from server)
+ */
+export interface ApiKey {
+    /** Unique key ID */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Key prefix (first 8 chars for identification) */
+    keyPrefix: string;
+    /** Permission configuration */
+    permissions: ApiKeyPermissions | string[];
+    /** Scope type */
+    scopeType: ScopeType;
+    /** Environment */
+    environment: Environment;
+    /** Allowed agent IDs (null = all agents) */
+    allowedAgentIds: string[] | null;
+    /** Allowed IP addresses (null = all IPs) */
+    allowedIps: string[] | null;
+    /** Whether key is active */
+    isActive: boolean;
+    /** Last usage timestamp */
+    lastUsedAt: string | null;
+    /** Total usage count */
+    usageCount: number;
+    /** Expiration date */
+    expiresAt: string | null;
+    /** Creation timestamp */
+    createdAt: string;
+}
+/**
+ * Result of creating an API key (includes secret)
+ */
+export interface CreateApiKeyResult extends ApiKey {
+    /**
+     * The full API key value
+     * IMPORTANT: This is only returned once and cannot be retrieved later!
+     * Store it securely.
+     */
+    key: string;
+}
+/**
+ * Create a new API key with specified permissions and scoping
+ *
+ * @param options - API key configuration
+ * @returns Created key with secret (only returned once!)
+ *
+ * @example
+ * ```typescript
+ * // Create a production write key
+ * const result = await apiKeys.create({
+ *   name: 'Production SDK Key',
+ *   permissions: { read: true, write: true, delete: false }
+ * });
+ *
+ * // Save the key securely - it won't be shown again!
+ * console.log('Save this key:', result.key);
+ * ```
+ */
+export declare function create(options: CreateApiKeyOptions): Promise<CreateApiKeyResult>;
+/**
+ * List all API keys for the authenticated company
+ *
+ * @returns Array of API keys (without secrets)
+ *
+ * @example
+ * ```typescript
+ * const keys = await apiKeys.list();
+ * console.log(`Found ${keys.length} API keys`);
+ *
+ * // Filter by environment
+ * const prodKeys = keys.filter(k => k.environment === 'production');
+ * ```
+ */
+export declare function list(): Promise<ApiKey[]>;
+/**
+ * Revoke (deactivate) an API key
+ *
+ * @param keyId - ID of the key to revoke
+ *
+ * @example
+ * ```typescript
+ * // Revoke a compromised key
+ * await apiKeys.revoke('key-id-to-revoke');
+ * ```
+ */
+export declare function revoke(keyId: string): Promise<void>;
+/**
+ * Rotate an API key (revoke old, create new with same config)
+ *
+ * @param keyId - ID of the key to rotate
+ * @param options - Optional overrides for the new key
+ * @returns New key with secret
+ *
+ * @example
+ * ```typescript
+ * // Rotate a key periodically
+ * const existingKeys = await apiKeys.list();
+ * const oldKey = existingKeys.find(k => k.name === 'Production Key');
+ *
+ * if (oldKey) {
+ *   const newKey = await apiKeys.rotate(oldKey.id);
+ *   // Update your systems with newKey.key
+ *   console.log('New key:', newKey.key);
+ * }
+ * ```
+ */
+export declare function rotate(keyId: string, options?: Partial<CreateApiKeyOptions>): Promise<CreateApiKeyResult>;
+/**
+ * Test an API key connection
+ *
+ * @param apiKey - The full API key value to test
+ * @param agentId - Optional agent ID to test with
+ * @returns Test result
+ *
+ * @example
+ * ```typescript
+ * const result = await apiKeys.test('thk_...', 'my-agent-id');
+ * if (result.success) {
+ *   console.log('Key is valid!');
+ * }
+ * ```
+ */
+export declare function test(apiKey: string, agentId?: string): Promise<{
+    success: boolean;
+    error?: string;
+    testTraceId?: string;
+}>;
+/**
+ * Check if an API key has a specific permission
+ */
+export declare function hasPermission(key: ApiKey, permission: 'read' | 'write' | 'delete'): boolean;
+/**
+ * Check if an API key is expired
+ */
+export declare function isExpired(key: ApiKey): boolean;
+/**
+ * Check if an API key is valid (active and not expired)
+ */
+export declare function isValid(key: ApiKey): boolean;
+/**
+ * Get time until key expires (in milliseconds)
+ * Returns null if key doesn't expire
+ */
+export declare function getTimeUntilExpiry(key: ApiKey): number | null;
+/**
+ * Check if a key can access a specific agent
+ */
+export declare function canAccessAgent(key: ApiKey, agentId: string): boolean;
+export declare const apiKeys: {
+    create: typeof create;
+    list: typeof list;
+    revoke: typeof revoke;
+    rotate: typeof rotate;
+    test: typeof test;
+    hasPermission: typeof hasPermission;
+    isExpired: typeof isExpired;
+    isValid: typeof isValid;
+    getTimeUntilExpiry: typeof getTimeUntilExpiry;
+    canAccessAgent: typeof canAccessAgent;
+};