@wilnertech/halopsa-mcp-server 1.0.0

package/dist/tools/assets.js

@@ -0,0 +1,732 @@
+/**
+ * HaloPSA Asset tools with token optimization
+ * Provides CRUD operations for assets with caching, deduplication, and custom field inspection
+ *
+ * CRITICAL: Assets are the primary billing entity - accuracy is essential
+ * - Only ACTIVE assets (status_id=1) count toward billing
+ * - Duplicates cause billing errors = revenue loss
+ */
+import { z } from 'zod';
+import { formatResponse } from '../utils/formatter.js';
+import { TTL } from '../cache/memory-cache.js';
+import { FormatOptionsSchema, ConfidenceThresholds } from '../schemas/common.js';
+// =============================================================================
+// Zod Schemas for Input Validation
+// =============================================================================
+/**
+ * List assets schema
+ */
+export const ListAssetsArgsSchema = z.object({
+    client_id: z.number().int().optional()
+        .describe('Filter by client ID (REQUIRED for multi-tenant environments)'),
+    site_id: z.number().int().optional()
+        .describe('Filter by site/location ID'),
+    assettype_id: z.number().int().optional()
+        .describe('Filter by asset type ID'),
+    status_id: z.number().int().optional()
+        .describe('Filter by status (1=Active, 2=Inactive, 3=Retired, 4=Deleted)'),
+    search: z.string().optional()
+        .describe('Search term (searches across multiple fields)'),
+    count: z.number().int().min(1).max(100).optional()
+        .describe('Number of results per page (max 100, default 50)'),
+    page_no: z.number().int().min(1).optional()
+        .describe('Page number (1-indexed, default 1)'),
+    includeactive: z.boolean().optional()
+        .describe('Include active assets (default true)'),
+    includeinactive: z.boolean().optional()
+        .describe('Include inactive assets (default false)'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Get single asset schema
+ */
+export const GetAssetArgsSchema = z.object({
+    asset_id: z.number().int()
+        .describe('HaloPSA asset ID'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Search assets by serial number schema
+ */
+export const SearchAssetsBySerialArgsSchema = z.object({
+    serial_number: z.string().min(1)
+        .describe('Serial number to search for (key_field)'),
+    client_id: z.number().int().optional()
+        .describe('Limit search to specific client'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Search assets by hostname schema
+ */
+export const SearchAssetsByHostnameArgsSchema = z.object({
+    hostname: z.string().min(1)
+        .describe('Hostname to search for (key_field2)'),
+    client_id: z.number().int().optional()
+        .describe('Limit search to specific client'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Create asset schema
+ */
+export const CreateAssetArgsSchema = z.object({
+    client_id: z.number().int()
+        .describe('Client ID to create asset under'),
+    site_id: z.number().int().optional()
+        .describe('Site/location ID'),
+    assettype_id: z.number().int()
+        .describe('Asset type ID'),
+    inventory_number: z.string().optional()
+        .describe('Asset tag/identifier'),
+    key_field: z.string().optional()
+        .describe('Serial number (PRIMARY deduplication field)'),
+    key_field2: z.string().optional()
+        .describe('Hostname (SECONDARY deduplication field)'),
+    status_id: z.number().int().optional()
+        .describe('Status ID (1=Active, 2=Inactive, 3=Retired, 4=Deleted)'),
+    warranty_end: z.string().optional()
+        .describe('Warranty expiration date (ISO 8601)'),
+    notes: z.string().optional()
+        .describe('Additional notes'),
+    fields: z.array(z.object({
+        id: z.number().int(),
+        value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    })).optional()
+        .describe('Custom fields array'),
+});
+/**
+ * Update asset schema
+ */
+export const UpdateAssetArgsSchema = z.object({
+    asset_id: z.number().int()
+        .describe('HaloPSA asset ID to update'),
+    site_id: z.number().int().optional()
+        .describe('Site/location ID'),
+    assettype_id: z.number().int().optional()
+        .describe('Asset type ID'),
+    inventory_number: z.string().optional()
+        .describe('Asset tag/identifier'),
+    key_field: z.string().optional()
+        .describe('Serial number'),
+    key_field2: z.string().optional()
+        .describe('Hostname'),
+    status_id: z.number().int().optional()
+        .describe('Status ID'),
+    warranty_end: z.string().optional()
+        .describe('Warranty expiration date (ISO 8601)'),
+    last_seen: z.string().optional()
+        .describe('Last seen date (ISO 8601)'),
+    notes: z.string().optional()
+        .describe('Additional notes'),
+    fields: z.array(z.object({
+        id: z.number().int(),
+        value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+    })).optional()
+        .describe('Custom fields array'),
+});
+/**
+ * Delete asset schema
+ */
+export const DeleteAssetArgsSchema = z.object({
+    asset_id: z.number().int()
+        .describe('HaloPSA asset ID to delete'),
+});
+/**
+ * List asset custom fields schema (for inspection)
+ */
+export const ListAssetCustomFieldsArgsSchema = z.object({
+    asset_id: z.number().int()
+        .describe('HaloPSA asset ID to inspect custom fields'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Get asset field schema schema
+ */
+export const GetAssetFieldSchemaArgsSchema = z.object({
+    client_id: z.number().int().optional()
+        .describe('Limit to specific client'),
+    sample_size: z.number().int().min(1).max(100).optional()
+        .describe('Number of assets to analyze (default 50)'),
+    format_options: FormatOptionsSchema,
+});
+/**
+ * Find asset match schema (deduplication)
+ */
+export const FindAssetMatchArgsSchema = z.object({
+    serial_number: z.string().optional()
+        .describe('Serial number to search for (primary match field)'),
+    hostname: z.string().optional()
+        .describe('Hostname to search for (secondary match field)'),
+    client_id: z.number().int()
+        .describe('Client ID to scope search'),
+});
+/**
+ * Scan asset duplicates schema
+ */
+export const ScanAssetDuplicatesArgsSchema = z.object({
+    client_id: z.number().int().optional()
+        .describe('Limit scan to specific client'),
+    scan_field: z.enum(['serial_number', 'hostname', 'both']).optional()
+        .describe('Field to scan for duplicates (default: both)'),
+    format_options: FormatOptionsSchema,
+});
+// =============================================================================
+// Tool Implementations
+// =============================================================================
+/**
+ * List assets with optional filtering and token optimization
+ * Uses 1-minute cache TTL (billing-critical data)
+ */
+export async function listAssets(client, args) {
+    const params = {};
+    // Build query parameters
+    if (args.client_id !== undefined) {
+        params.client_id = args.client_id;
+    }
+    if (args.site_id !== undefined) {
+        params.site_id = args.site_id;
+    }
+    if (args.assettype_id !== undefined) {
+        params.assettype_id = args.assettype_id;
+    }
+    if (args.status_id !== undefined) {
+        params.status_id = args.status_id;
+    }
+    if (args.search !== undefined) {
+        params.search = args.search;
+    }
+    if (args.count !== undefined) {
+        params.count = args.count;
+    }
+    if (args.page_no !== undefined) {
+        params.page_no = args.page_no;
+    }
+    if (args.includeactive !== undefined) {
+        params.includeactive = args.includeactive;
+    }
+    if (args.includeinactive !== undefined) {
+        params.includeinactive = args.includeinactive;
+    }
+    const formatOptions = args.format_options || {};
+    // Generate cache key based on filters
+    const cacheKey = `assets:client_${args.client_id || 'all'}:site_${args.site_id || 'all'}`;
+    const response = await client.getCached('/Asset', params, {
+        enabled: true,
+        ttl: TTL.ASSET_LIST,
+        keyPrefix: cacheKey,
+    });
+    return formatResponse(response.assets, formatOptions, { record_count: response.record_count, page_count: response.page_count });
+}
+/**
+ * Get a single asset by ID with full details including custom fields
+ */
+export async function getAsset(client, args) {
+    const formatOptions = args.format_options || {};
+    const response = await client.get(`/Asset/${args.asset_id}`);
+    return formatResponse(response, formatOptions);
+}
+/**
+ * Search assets by serial number
+ * Returns warning if multiple found (potential duplicates)
+ */
+export async function searchAssetsBySerial(client, args) {
+    const params = {
+        search: args.serial_number,
+        count: 100,
+    };
+    if (args.client_id !== undefined) {
+        params.client_id = args.client_id;
+    }
+    const formatOptions = args.format_options || {};
+    // No caching for search results
+    const response = await client.get('/Asset', params);
+    // Filter to exact serial matches
+    const exactMatches = response.assets.filter((asset) => asset.key_field?.toLowerCase() === args.serial_number.toLowerCase());
+    if (exactMatches.length === 0) {
+        return JSON.stringify({
+            serial_number: args.serial_number,
+            matches: [],
+            count: 0,
+            message: 'No assets found with this serial number',
+        });
+    }
+    // Warning if duplicates found
+    const warning = exactMatches.length > 1
+        ? `WARNING: Multiple assets found with serial number ${args.serial_number}. Potential duplicates detected.`
+        : undefined;
+    const result = {
+        serial_number: args.serial_number,
+        matches: JSON.parse(formatResponse(exactMatches, formatOptions)),
+        count: exactMatches.length,
+        ...(warning && { warning }),
+    };
+    return JSON.stringify(result, null, 2);
+}
+/**
+ * Search assets by hostname
+ * Returns warning if multiple found (potential duplicates)
+ */
+export async function searchAssetsByHostname(client, args) {
+    const params = {
+        search: args.hostname,
+        count: 100,
+    };
+    if (args.client_id !== undefined) {
+        params.client_id = args.client_id;
+    }
+    const formatOptions = args.format_options || {};
+    const response = await client.get('/Asset', params);
+    // Filter to exact hostname matches
+    const exactMatches = response.assets.filter((asset) => asset.key_field2?.toLowerCase() === args.hostname.toLowerCase());
+    if (exactMatches.length === 0) {
+        return JSON.stringify({
+            hostname: args.hostname,
+            matches: [],
+            count: 0,
+            message: 'No assets found with this hostname',
+        });
+    }
+    const warning = exactMatches.length > 1
+        ? `WARNING: Multiple assets found with hostname ${args.hostname}. Potential duplicates detected.`
+        : undefined;
+    const result = {
+        hostname: args.hostname,
+        matches: JSON.parse(formatResponse(exactMatches, formatOptions)),
+        count: exactMatches.length,
+        ...(warning && { warning }),
+    };
+    return JSON.stringify(result, null, 2);
+}
+/**
+ * Create a new asset
+ * Invalidates asset cache on success
+ */
+export async function createAsset(client, args) {
+    const assetData = {
+        client_id: args.client_id,
+        assettype_id: args.assettype_id,
+    };
+    // Add optional fields
+    if (args.site_id !== undefined) {
+        assetData.site_id = args.site_id;
+    }
+    if (args.inventory_number !== undefined) {
+        assetData.inventory_number = args.inventory_number;
+    }
+    if (args.key_field !== undefined) {
+        assetData.key_field = args.key_field;
+    }
+    if (args.key_field2 !== undefined) {
+        assetData.key_field2 = args.key_field2;
+    }
+    if (args.status_id !== undefined) {
+        assetData.status_id = args.status_id;
+    }
+    if (args.warranty_end !== undefined) {
+        assetData.warranty_end = args.warranty_end;
+    }
+    if (args.notes !== undefined) {
+        assetData.notes = args.notes;
+    }
+    if (args.fields !== undefined) {
+        assetData.fields = args.fields;
+    }
+    const response = await client.post('/Asset', assetData);
+    // Invalidate asset caches
+    client.invalidateCache(`assets:client_${args.client_id}*`);
+    client.invalidateCache('assets:client_all*');
+    return formatResponse(response, { format: 'detailed' });
+}
+/**
+ * Update an existing asset
+ * Invalidates asset cache on success
+ */
+export async function updateAsset(client, args) {
+    const assetData = {};
+    // Build update payload with only provided fields
+    if (args.site_id !== undefined) {
+        assetData.site_id = args.site_id;
+    }
+    if (args.assettype_id !== undefined) {
+        assetData.assettype_id = args.assettype_id;
+    }
+    if (args.inventory_number !== undefined) {
+        assetData.inventory_number = args.inventory_number;
+    }
+    if (args.key_field !== undefined) {
+        assetData.key_field = args.key_field;
+    }
+    if (args.key_field2 !== undefined) {
+        assetData.key_field2 = args.key_field2;
+    }
+    if (args.status_id !== undefined) {
+        assetData.status_id = args.status_id;
+    }
+    if (args.warranty_end !== undefined) {
+        assetData.warranty_end = args.warranty_end;
+    }
+    if (args.last_seen !== undefined) {
+        assetData.last_seen = args.last_seen;
+    }
+    if (args.notes !== undefined) {
+        assetData.notes = args.notes;
+    }
+    if (args.fields !== undefined) {
+        assetData.fields = args.fields;
+    }
+    if (Object.keys(assetData).length === 0) {
+        return JSON.stringify({
+            error: true,
+            message: 'At least one field must be provided for update',
+        }, null, 2);
+    }
+    // HaloPSA uses POST for updates
+    const response = await client.post(`/Asset/${args.asset_id}`, assetData);
+    // Invalidate asset caches
+    client.invalidateCache('assets:*');
+    return formatResponse(response, { format: 'detailed' });
+}
+/**
+ * Delete an asset (soft delete - sets status to Deleted)
+ * Invalidates asset cache on success
+ */
+export async function deleteAsset(client, args) {
+    await client.delete(`/Asset/${args.asset_id}`);
+    // Invalidate asset caches
+    client.invalidateCache('assets:*');
+    return JSON.stringify({
+        success: true,
+        message: `Asset ${args.asset_id} deleted successfully`,
+        deleted_id: args.asset_id,
+    }, null, 2);
+}
+/**
+ * List custom fields for a specific asset
+ * Useful for inspecting custom field structure before updates
+ */
+export async function listAssetCustomFields(client, args) {
+    const formatOptions = args.format_options || {};
+    const asset = await client.get(`/Asset/${args.asset_id}`);
+    const customFields = asset.fields || [];
+    const result = {
+        asset_id: args.asset_id,
+        asset_name: asset.key_field2 || asset.inventory_number || `Asset ${asset.id}`,
+        custom_field_count: customFields.length,
+        custom_fields: customFields,
+    };
+    if (formatOptions.format === 'detailed') {
+        return JSON.stringify(result, null, 2);
+    }
+    return JSON.stringify(result);
+}
+/**
+ * Analyze custom field schema across multiple assets
+ * Returns field definitions with sample values and value types
+ */
+export async function getAssetFieldSchema(client, args) {
+    const sampleSize = args.sample_size || 50;
+    const formatOptions = args.format_options || {};
+    const params = {
+        count: sampleSize,
+        includeactive: true,
+        includeinactive: true,
+    };
+    if (args.client_id !== undefined) {
+        params.client_id = args.client_id;
+    }
+    const response = await client.get('/Asset', params);
+    // Analyze custom fields across all assets
+    const fieldMap = new Map();
+    for (const asset of response.assets) {
+        const fields = asset.fields || [];
+        for (const field of fields) {
+            const existing = fieldMap.get(field.id);
+            if (existing) {
+                // Update sample values and usage count
+                if (!existing.sample_values.includes(field.value) && existing.sample_values.length < 5) {
+                    existing.sample_values.push(field.value);
+                }
+                existing.usage_count++;
+                // Determine value type
+                const valueType = getValueType(field.value);
+                if (existing.value_type !== valueType && existing.value_type !== 'mixed') {
+                    existing.value_type = 'mixed';
+                }
+            }
+            else {
+                fieldMap.set(field.id, {
+                    field_id: field.id,
+                    name: field.name,
+                    sample_values: [field.value],
+                    value_type: getValueType(field.value),
+                    usage_count: 1,
+                });
+            }
+        }
+    }
+    const fieldSchemas = Array.from(fieldMap.values()).sort((a, b) => a.field_id - b.field_id);
+    const result = {
+        client_id: args.client_id || 'all',
+        assets_analyzed: response.assets.length,
+        unique_fields: fieldSchemas.length,
+        field_schemas: fieldSchemas,
+    };
+    if (formatOptions.format === 'detailed') {
+        return JSON.stringify(result, null, 2);
+    }
+    return JSON.stringify(result);
+}
+/**
+ * Find matching asset using deduplication algorithm
+ * Returns confidence scoring and action recommendation
+ *
+ * Confidence Thresholds:
+ * - 100%: Exact serial match -> Auto-update
+ * - 85%: Hostname match only -> Manual review
+ * - 0%: No match -> Create new
+ */
+export async function findAssetMatch(client, args) {
+    // Get all assets for client with caching
+    const response = await client.getCached('/Asset', {
+        client_id: args.client_id,
+        count: 1000,
+        includeactive: true,
+        includeinactive: true,
+    }, {
+        enabled: true,
+        ttl: TTL.ASSET_LIST,
+        keyPrefix: `assets:client_${args.client_id}`,
+    });
+    if (!response.assets || response.assets.length === 0) {
+        return JSON.stringify({
+            match: null,
+            confidence: 0,
+            matchField: 'none',
+            action: 'CreateNew',
+        }, null, 2);
+    }
+    // 1. Exact serial number match (100% confidence)
+    if (args.serial_number) {
+        const serialMatch = response.assets.find((asset) => asset.key_field?.toLowerCase() === args.serial_number?.toLowerCase());
+        if (serialMatch) {
+            return JSON.stringify({
+                match: serialMatch,
+                confidence: ConfidenceThresholds.ASSET_SERIAL_EXACT,
+                matchField: 'serial_number (exact)',
+                action: 'Update',
+            }, null, 2);
+        }
+    }
+    // 2. Hostname match only (85% confidence - requires manual review)
+    if (args.hostname) {
+        const hostnameMatches = response.assets.filter((asset) => asset.key_field2?.toLowerCase() === args.hostname?.toLowerCase());
+        if (hostnameMatches.length === 1) {
+            return JSON.stringify({
+                match: hostnameMatches[0],
+                confidence: ConfidenceThresholds.ASSET_HOSTNAME_ONLY,
+                matchField: 'hostname (serial mismatch)',
+                action: 'ManualReview',
+                warning: 'Hostname match found but serial number does not match. Manual review required.',
+            }, null, 2);
+        }
+        if (hostnameMatches.length > 1) {
+            return JSON.stringify({
+                match: null,
+                confidence: 0.5,
+                matchField: 'hostname (multiple)',
+                action: 'ManualReview',
+                warning: `Multiple assets found with hostname ${args.hostname}. Duplicates detected.`,
+                matches: hostnameMatches,
+            }, null, 2);
+        }
+    }
+    // 3. No match found - create new
+    return JSON.stringify({
+        match: null,
+        confidence: 0,
+        matchField: 'none',
+        action: 'CreateNew',
+    }, null, 2);
+}
+/**
+ * Scan for duplicate assets
+ * Returns groups of duplicate entities with confidence scores
+ */
+export async function scanAssetDuplicates(client, args) {
+    const scanField = args.scan_field || 'both';
+    const formatOptions = args.format_options || {};
+    const params = {
+        count: 1000,
+        includeactive: true,
+        includeinactive: true,
+    };
+    if (args.client_id !== undefined) {
+        params.client_id = args.client_id;
+    }
+    const response = await client.getCached('/Asset', params, {
+        enabled: true,
+        ttl: TTL.ASSET_LIST,
+        keyPrefix: args.client_id ? `assets:client_${args.client_id}` : 'assets:client_all',
+    });
+    const duplicates = [];
+    // Scan by serial number
+    if (scanField === 'serial_number' || scanField === 'both') {
+        const serialToAssets = new Map();
+        for (const asset of response.assets) {
+            if (asset.key_field) {
+                const normalizedSerial = asset.key_field.toLowerCase();
+                const existing = serialToAssets.get(normalizedSerial) || [];
+                existing.push(asset);
+                serialToAssets.set(normalizedSerial, existing);
+            }
+        }
+        for (const [serial, assets] of serialToAssets.entries()) {
+            if (assets.length > 1) {
+                duplicates.push({
+                    type: 'asset',
+                    matchField: 'serial_number',
+                    matchValue: serial,
+                    confidence: 'High', // Exact serial match = high confidence
+                    entity_count: assets.length,
+                    entities: assets.map((a) => ({
+                        id: a.id,
+                        name: a.inventory_number || `Asset ${a.id}`,
+                        serial_number: a.key_field,
+                        hostname: a.key_field2,
+                    })),
+                });
+            }
+        }
+    }
+    // Scan by hostname
+    if (scanField === 'hostname' || scanField === 'both') {
+        const hostnameToAssets = new Map();
+        for (const asset of response.assets) {
+            if (asset.key_field2) {
+                const normalizedHostname = asset.key_field2.toLowerCase();
+                const existing = hostnameToAssets.get(normalizedHostname) || [];
+                existing.push(asset);
+                hostnameToAssets.set(normalizedHostname, existing);
+            }
+        }
+        for (const [hostname, assets] of hostnameToAssets.entries()) {
+            if (assets.length > 1) {
+                // Check if these are already captured by serial number scan
+                const serialNumbers = new Set(assets.map((a) => a.key_field?.toLowerCase()).filter(Boolean));
+                const isNewDuplicate = serialNumbers.size > 1; // Different serials = new duplicate group
+                if (isNewDuplicate) {
+                    duplicates.push({
+                        type: 'asset',
+                        matchField: 'hostname',
+                        matchValue: hostname,
+                        confidence: 'Medium', // Hostname only = medium confidence
+                        entity_count: assets.length,
+                        entities: assets.map((a) => ({
+                            id: a.id,
+                            name: a.inventory_number || `Asset ${a.id}`,
+                            serial_number: a.key_field,
+                            hostname: a.key_field2,
+                        })),
+                    });
+                }
+            }
+        }
+    }
+    const result = {
+        client_id: args.client_id || 'all',
+        scan_field: scanField,
+        assets_scanned: response.assets.length,
+        duplicates_found: duplicates.length,
+        duplicates,
+    };
+    if (formatOptions.format === 'detailed') {
+        return JSON.stringify(result, null, 2);
+    }
+    return JSON.stringify(result);
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Determine the type of a custom field value
+ */
+function getValueType(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string')
+        return 'string';
+    if (typeof value === 'number')
+        return 'number';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    return 'mixed';
+}
+// =============================================================================
+// Tool Definitions (for ToolRegistry)
+// =============================================================================
+export const listAssetsTool = {
+    name: 'list_halopsa_assets',
+    description: 'List HaloPSA assets with optional filtering, caching (1min TTL), and token optimization. CRITICAL: Only status_id=1 (Active) assets count for billing.',
+    schema: ListAssetsArgsSchema,
+    handler: listAssets,
+};
+export const getAssetTool = {
+    name: 'get_halopsa_asset',
+    description: 'Get a single HaloPSA asset by ID with full details including custom fields (fields[] array)',
+    schema: GetAssetArgsSchema,
+    handler: getAsset,
+};
+export const searchAssetsBySerialTool = {
+    name: 'search_halopsa_assets_by_serial',
+    description: 'Search HaloPSA assets by serial number (key_field). Returns warning if multiple found (potential duplicates).',
+    schema: SearchAssetsBySerialArgsSchema,
+    handler: searchAssetsBySerial,
+};
+export const searchAssetsByHostnameTool = {
+    name: 'search_halopsa_assets_by_hostname',
+    description: 'Search HaloPSA assets by hostname (key_field2). Returns warning if multiple found.',
+    schema: SearchAssetsByHostnameArgsSchema,
+    handler: searchAssetsByHostname,
+};
+export const createAssetTool = {
+    name: 'create_halopsa_asset',
+    description: 'Create a new HaloPSA asset. Invalidates asset cache. IMPORTANT: Use find_halopsa_asset_match first to prevent duplicates.',
+    schema: CreateAssetArgsSchema,
+    handler: createAsset,
+};
+export const updateAssetTool = {
+    name: 'update_halopsa_asset',
+    description: 'Update an existing HaloPSA asset. Invalidates asset cache. Uses POST (HaloPSA convention).',
+    schema: UpdateAssetArgsSchema,
+    handler: updateAsset,
+};
+export const deleteAssetTool = {
+    name: 'delete_halopsa_asset',
+    description: 'Delete a HaloPSA asset. Invalidates asset cache.',
+    schema: DeleteAssetArgsSchema,
+    handler: deleteAsset,
+};
+export const listAssetCustomFieldsTool = {
+    name: 'list_halopsa_asset_custom_fields',
+    description: 'List custom fields for a specific asset. Useful for inspecting field structure before updates.',
+    schema: ListAssetCustomFieldsArgsSchema,
+    handler: listAssetCustomFields,
+};
+export const getAssetFieldSchemaTool = {
+    name: 'get_halopsa_asset_field_schema',
+    description: 'Analyze custom field definitions across multiple assets. Returns field IDs, names, sample values, and value types.',
+    schema: GetAssetFieldSchemaArgsSchema,
+    handler: getAssetFieldSchema,
+};
+export const findAssetMatchTool = {
+    name: 'find_halopsa_asset_match',
+    description: 'Find matching asset using deduplication algorithm with confidence scoring. Returns action recommendation (Update/CreateNew/ManualReview). CRITICAL for billing accuracy.',
+    schema: FindAssetMatchArgsSchema,
+    handler: findAssetMatch,
+};
+export const scanAssetDuplicatesTool = {
+    name: 'scan_halopsa_asset_duplicates',
+    description: 'Scan for duplicate assets. Returns groups with confidence scores. Run before billing cycles.',
+    schema: ScanAssetDuplicatesArgsSchema,
+    handler: scanAssetDuplicates,
+};
+//# sourceMappingURL=assets.js.map