@thinkhive/sdk 3.3.0 → 4.0.1

package/MIGRATION.md

@@ -1,6 +1,86 @@
-# Migration Guide: v2.x to v3.0
+# Migration Guide
 
-This guide helps you migrate from ThinkHive SDK v2.x to v3.0.
+This guide covers migration between major versions of the ThinkHive SDK.
+
+---
+
+## v3.x to v4.0
+
+### Breaking Changes
+
+#### `apiVersion` Removed from `InitOptions`
+
+The `apiVersion` configuration option has been removed. The SDK now handles API routing internally -- modules automatically route to the correct API version.
+
+```diff
+  init({
+    apiKey: 'th_xxx',
+    serviceName: 'my-agent',
+-   apiVersion: 'v3',
+  });
+```
+
+#### Default Endpoint Changed
+
+The default endpoint is now `https://app.thinkhive.ai` (previously pointed to the staging Cloud Run URL).
+
+```diff
+  // If you were relying on the old default, no action needed —
+  // the new default points to production.
+  // If you explicitly set the old staging URL, remove it:
+  init({
+    apiKey: 'th_xxx',
+    serviceName: 'my-agent',
+-   endpoint: 'https://thinkhivemind-h25z7pvd3q-uc.a.run.app',
+  });
+```
+
+#### Calibration API Changes
+
+`calibration.recordOutcome()` and `calibration.reliabilityDiagram()` have been removed. Use `calibration.status()` to check calibration state.
+
+```diff
+- await calibration.recordOutcome({
+-   runId: run.id,
+-   predictionType: 'churn_risk',
+-   predictedValue: 0.7,
+-   actualOutcome: 1,
+- });
+-
+- const diagram = await calibration.reliabilityDiagram(agentId);
+
+  // Still available:
+  const status = await calibration.status(agentId, 'churn_risk');
+```
+
+#### OTLP Init Requires API Key
+
+Initializing the SDK with only an `agentId` is no longer sufficient for OTLP-based tracing. You must provide an `apiKey`.
+
+```diff
+  init({
++   apiKey: 'th_xxx',
+    agentId: 'agent-123',
+    serviceName: 'my-agent',
+  });
+```
+
+#### Version Bump
+
+The SDK version is now `4.0.0`. Update your `package.json`:
+
+```diff
+  "dependencies": {
+-   "@thinkhive/sdk": "^3.3.0"
++   "@thinkhive/sdk": "^4.0.0"
+  }
+```
+
+---
+
+## v2.x to v3.0
+
+This section covers migration from ThinkHive SDK v2.x to v3.0.
 
 ## Breaking Changes
 
@@ -48,13 +128,12 @@ init({
   serviceName: 'my-agent',
 });
 
-// v3
+// v3+
 import { init } from '@thinkhive/sdk';
 
 init({
   apiKey: 'th_xxx',
   serviceName: 'my-agent',
-  apiVersion: 'v3', // Default is v3
 });
 ```
 
@@ -196,14 +275,6 @@ import { calibration } from '@thinkhive/sdk';
 const status = await calibration.status('agent_123', 'churn_risk');
 console.log(`Brier score: ${status.brierScore}`);
 console.log(`Is calibrated: ${status.isCalibrated}`);
-
-// Record prediction outcomes
-await calibration.recordOutcome({
-  runId: run.id,
-  predictionType: 'churn_risk',
-  predictedValue: 0.7,  // We predicted 70% churn risk
-  actualOutcome: 1,     // Customer did churn
-});
 ```
 
 ## Deprecated APIs

package/README.md

@@ -1,4 +1,4 @@
-# ThinkHive SDK v3.3.0
+# ThinkHive SDK v4.0.0
 
 The official JavaScript/TypeScript SDK for [ThinkHive](https://thinkhive.ai) - AI Agent Observability Platform.
 
@@ -27,7 +27,7 @@ import { init, runs, traceLLM, shutdown } from '@thinkhive/sdk';
 
 // Initialize the SDK
 init({
-  apiKey: 'th_your_api_key',
+  apiKey: 'thk_your_api_key',
   serviceName: 'my-ai-agent',
   autoInstrument: true,
   frameworks: ['langchain', 'openai'],
@@ -36,7 +36,7 @@ init({
 // Create a run (atomic unit of work)
 const run = await runs.create({
   agentId: 'weather-agent',
-  conversation: [
+  conversationMessages: [
     { role: 'user', content: 'What is the weather in San Francisco?' },
     { role: 'assistant', content: 'The weather in San Francisco is currently 65°F and sunny.' }
   ],
@@ -54,7 +54,7 @@ await shutdown();
 ```typescript
 import { init, traceLLM, traceRetrieval, traceTool, traceChain } from '@thinkhive/sdk';
 
-init({ apiKey: 'th_your_api_key', serviceName: 'my-agent' });
+init({ apiKey: 'thk_your_api_key', serviceName: 'my-agent' });
 
 // Trace an LLM call
 const response = await traceLLM({
@@ -194,14 +194,17 @@ const confident = getHighConfidenceClaims(claimList, 0.9);
 ```typescript
 import { calibration, calculateBrierScore, isWellCalibrated } from '@thinkhive/sdk';
 
-// Get calibration status
-const status = await calibration.getStatus(agentId);
+// Get calibration status for a prediction type
+const status = await calibration.status(agentId, 'churn_risk');
+
+// Get all calibration metrics
+const metrics = await calibration.allMetrics(agentId);
 
 // Calculate Brier score for predictions
-const brierScore = calculateBrierScore(predictions, outcomes);
+const brierScore = calculateBrierScore(predictions);
 
 // Check if well calibrated
-if (isWellCalibrated(status)) {
+if (isWellCalibrated(brierScore)) {
   console.log('Agent predictions are well calibrated');
 }
 ```
@@ -284,7 +287,7 @@ import { init } from '@thinkhive/sdk';
 
 // Initialize with auto-instrumentation
 init({
-  apiKey: 'th_your_api_key',
+  apiKey: 'thk_your_api_key',
   serviceName: 'my-ai-agent',
   autoInstrument: true,
   frameworks: ['langchain', 'openai', 'anthropic']
@@ -306,10 +309,10 @@ init({
 | Variable | Description |
 |----------|-------------|
 | `THINKHIVE_API_KEY` | Your ThinkHive API key |
-| `THINKHIVE_ENDPOINT` | Custom API endpoint (default: https://demo.thinkhive.ai) |
+| `THINKHIVE_ENDPOINT` | Custom API endpoint (default: https://app.thinkhive.ai) |
 | `THINKHIVE_SERVICE_NAME` | Service name for traces (optional) |
 
-## V3 Architecture
+## Architecture
 
 ### Key Concepts
 
@@ -344,7 +347,7 @@ init({
 | `roiAnalytics` | Business ROI and financial impact analysis |
 | `qualityMetrics` | RAG evaluation and hallucination detection |
 
-### New Evaluation APIs (v3.0)
+### Evaluation APIs
 
 | API | Description |
 |-----|-------------|
@@ -355,6 +358,15 @@ init({
 | `conversationEval` | Multi-turn conversation evaluation |
 | `transcriptPatterns` | Pattern detection in transcripts |
 
+## Upgrading from v3
+
+See [MIGRATION.md](MIGRATION.md) for the full v3 → v4 migration guide. Key changes:
+
+- **`apiVersion` removed** from `init()` options — routing is handled automatically per module
+- **`calibration.recordOutcome()`** and **`calibration.reliabilityDiagram()`** removed — use `calibration.status()` and `calibration.allMetrics()` instead
+- **Default endpoint** changed from staging to `https://app.thinkhive.ai`
+- **OTLP init** now requires `apiKey` (agent ID alone is not sufficient)
+
 ## API Reference
 
 See [API Documentation](https://docs.thinkhive.ai/sdk/javascript/reference) for complete type definitions.

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"]}