attio-mcp 0.1.2 → 1.0.0

package/dist/handlers/tool-configs/universal/index.d.ts

@@ -0,0 +1,1012 @@
+/**
+ * Universal MCP tool configurations - Main module
+ *
+ * This module implements the universal tool consolidation strategy from Issue #352
+ * to reduce tool count from 70 to ~30 tools while maintaining full functionality.
+ *
+ * Universal tools use parameter-based routing with resource_type discrimination
+ * to provide consolidated operations across companies, people, records, and tasks.
+ */
+import { coreOperationsToolConfigs, coreOperationsToolDefinitions } from './core/index.js';
+import { advancedOperationsToolConfigs, advancedOperationsToolDefinitions } from './operations/index.js';
+/**
+ * Simple no-auth health-check tool to support unauthenticated capability scanning
+ * This tool intentionally performs no Attio API calls and always succeeds.
+ */
+export declare const healthCheckToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {};
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+};
+/**
+ * Backwards-compatible health-check alias for Smithery deployment validation
+ * This ensures both 'health-check' and 'aaa-health-check' work identically.
+ */
+export declare const healthCheckAliasToolDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {};
+        additionalProperties: boolean;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+};
+export declare const healthCheckConfig: {
+    name: string;
+    handler: (params: {
+        [key: string]: unknown;
+    }) => Promise<{
+        content: {
+            type: string;
+            data: {
+                readonly ok: true;
+                readonly name: "attio-mcp";
+                readonly echo: string | undefined;
+                readonly timestamp: string;
+                readonly environment: string;
+                readonly needs_api_key: true;
+            };
+        }[];
+        isError: boolean;
+    }>;
+    formatResult: (res: Record<string, unknown>) => string;
+};
+/**
+ * Backwards-compatible health-check config alias for Smithery deployment
+ * Uses the same handler as aaa-health-check but with the legacy name.
+ */
+export declare const healthCheckAliasConfig: {
+    name: string;
+    handler: (params: {
+        [key: string]: unknown;
+    }) => Promise<{
+        content: {
+            type: string;
+            data: {
+                readonly ok: true;
+                readonly name: "attio-mcp";
+                readonly echo: string | undefined;
+                readonly timestamp: string;
+                readonly environment: string;
+                readonly needs_api_key: true;
+            };
+        }[];
+        isError: boolean;
+    }>;
+    formatResult: (res: Record<string, unknown>) => string;
+};
+export { coreOperationsToolConfigs, coreOperationsToolDefinitions, advancedOperationsToolConfigs, advancedOperationsToolDefinitions, };
+export * from './types.js';
+export * from './schemas.js';
+export * from './shared-handlers.js';
+/**
+ * All universal tool configurations
+ * These replace 40+ resource-specific tools with 14 universal operations
+ */
+export declare const universalToolConfigs: {
+    'openai-search': import("../../tool-types.js").ToolConfig;
+    'openai-fetch': import("../../tool-types.js").ToolConfig;
+    'batch-search': import("./types.js").UniversalToolConfig<Record<string, unknown>, unknown>;
+    'advanced-search': import("./types.js").UniversalToolConfig<import("./types.js").AdvancedSearchParams, import("../../../types/attio.js").AttioRecord[]>;
+    'search-by-relationship': import("./types.js").UniversalToolConfig<import("./types.js").RelationshipSearchParams, import("../../../types/attio.js").AttioRecord[]>;
+    'search-by-content': import("./types.js").UniversalToolConfig<import("./types.js").ContentSearchParams, import("../../../types/attio.js").AttioRecord[]>;
+    'search-by-timeframe': import("./types.js").UniversalToolConfig<import("./types.js").TimeframeSearchParams, import("../../../types/attio.js").AttioRecord[]>;
+    'batch-operations': import("./types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown> | Record<string, unknown>[]>;
+    'create-note': import("./types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown>>;
+    'list-notes': import("./types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown>[]>;
+    'search-records': import("./types.js").UniversalToolConfig<import("./types.js").UniversalSearchParams, import("../../../types/attio.js").AttioRecord[]>;
+    'get-record-details': import("./types.js").UniversalToolConfig<import("./types.js").UniversalRecordDetailsParams, import("../../../types/attio.js").AttioRecord>;
+    'create-record': import("./types.js").UniversalToolConfig<import("./types.js").UniversalCreateParams, import("../../../types/attio.js").AttioRecord>;
+    'update-record': import("./types.js").UniversalToolConfig<import("./types.js").UniversalUpdateParams, import("../../../types/attio.js").EnhancedAttioRecord>;
+    'delete-record': import("./types.js").UniversalToolConfig<import("./types.js").UniversalDeleteParams, {
+        success: boolean;
+        record_id: string;
+    }>;
+    'get-attributes': import("./types.js").UniversalToolConfig<import("./types.js").UniversalAttributesParams, Record<string, unknown> | {
+        error: string;
+        success: boolean;
+    }>;
+    'discover-attributes': import("./types.js").UniversalToolConfig<{
+        resource_type: import("./types.js").UniversalResourceType;
+        categories?: string[];
+    }, Record<string, unknown> | {
+        error: string;
+        success: boolean;
+    }>;
+    'get-detailed-info': import("./types.js").UniversalToolConfig<import("./types.js").UniversalDetailedInfoParams, Record<string, unknown>>;
+    'aaa-health-check': {
+        name: string;
+        handler: (params: {
+            [key: string]: unknown;
+        }) => Promise<{
+            content: {
+                type: string;
+                data: {
+                    readonly ok: true;
+                    readonly name: "attio-mcp";
+                    readonly echo: string | undefined;
+                    readonly timestamp: string;
+                    readonly environment: string;
+                    readonly needs_api_key: true;
+                };
+            }[];
+            isError: boolean;
+        }>;
+        formatResult: (res: Record<string, unknown>) => string;
+    };
+    'health-check': {
+        name: string;
+        handler: (params: {
+            [key: string]: unknown;
+        }) => Promise<{
+            content: {
+                type: string;
+                data: {
+                    readonly ok: true;
+                    readonly name: "attio-mcp";
+                    readonly echo: string | undefined;
+                    readonly timestamp: string;
+                    readonly environment: string;
+                    readonly needs_api_key: true;
+                };
+            }[];
+            isError: boolean;
+        }>;
+        formatResult: (res: Record<string, unknown>) => string;
+    };
+};
+/**
+ * All universal tool definitions for MCP protocol
+ */
+export declare const universalToolDefinitions: {
+    'openai-search': {
+        readonly name: "search";
+        readonly description: "Search Attio data by query for OpenAI MCP clients.";
+        readonly inputSchema: {
+            type: "object";
+            properties: {
+                query: {
+                    type: "string";
+                    description: string;
+                };
+                type: {
+                    type: "string";
+                    enum: readonly ["companies", "people", "lists", "tasks", "all"];
+                    description: string;
+                };
+                limit: {
+                    type: "integer";
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+            };
+            required: readonly ["query"];
+            additionalProperties: boolean;
+        };
+        readonly annotations: {
+            readonly readOnlyHint: true;
+            readonly idempotentHint: true;
+        };
+    };
+    'openai-fetch': {
+        readonly name: "fetch";
+        readonly description: "Retrieve the full record payload for a search result ID.";
+        readonly inputSchema: {
+            type: "object";
+            properties: {
+                id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: readonly ["id"];
+            additionalProperties: boolean;
+        };
+        readonly annotations: {
+            readonly readOnlyHint: true;
+            readonly idempotentHint: true;
+        };
+    };
+    'batch-search': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                queries: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                    minItems: number;
+                };
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    description: string;
+                };
+            };
+            required: ("resource_type" | "queries")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'advanced-search': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                query: {
+                    type: "string";
+                    description: string;
+                };
+                filters: {
+                    type: "object";
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                sort_by: {
+                    type: "string";
+                    description: string;
+                };
+                sort_order: {
+                    type: "string";
+                    enum: string[];
+                    default: string;
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'search-by-relationship': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                relationship_type: {
+                    type: "string";
+                    enum: import("./types.js").RelationshipType[];
+                    description: string;
+                };
+                source_id: {
+                    type: "string";
+                    description: string;
+                };
+                target_resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                listId: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("source_id" | "relationship_type")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'search-by-content': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                content_type: {
+                    type: "string";
+                    enum: import("./types.js").ContentSearchType[];
+                    description: string;
+                };
+                search_query: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("resource_type" | "content_type" | "search_query")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'search-by-timeframe': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                timeframe_type: {
+                    type: "string";
+                    enum: import("./types.js").TimeframeType[];
+                    description: string;
+                };
+                start_date: {
+                    type: "string";
+                    format: string;
+                    description: string;
+                };
+                end_date: {
+                    type: "string";
+                    format: string;
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'batch-operations': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                operations: {
+                    type: "array";
+                    items: {
+                        type: "object";
+                        properties: {
+                            operation: {
+                                type: "string";
+                                enum: string[];
+                                description: string;
+                            };
+                            record_data: {
+                                type: "object";
+                                additionalProperties: boolean;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    description: string;
+                };
+                operation_type: {
+                    type: "string";
+                    enum: import("./types.js").BatchOperationType[];
+                    description: string;
+                };
+                records: {
+                    type: "array";
+                    items: {
+                        type: "object";
+                        additionalProperties: boolean;
+                    };
+                    description: string;
+                };
+                record_ids: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    'search-records': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                query: {
+                    type: "string";
+                    description: string;
+                };
+                filters: {
+                    type: "object";
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                search_type: {
+                    type: "string";
+                    enum: readonly ["basic", "content", "timeframe"];
+                    description: string;
+                };
+                fields: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+                match_type: {
+                    type: "string";
+                    enum: readonly ["exact", "partial", "fuzzy"];
+                    description: string;
+                };
+                sort: {
+                    type: "string";
+                    enum: readonly ["relevance", "created", "modified", "name"];
+                    description: string;
+                };
+                date_from: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                date_to: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                created_after: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                created_before: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                updated_after: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                updated_before: {
+                    type: "string";
+                    description: string;
+                    format: string;
+                };
+                timeframe: {
+                    type: "string";
+                    enum: readonly ["today", "yesterday", "this_week", "last_week", "this_month", "last_month", "last_7_days", "last_30_days", "last_90_days"];
+                    description: string;
+                };
+                date_field: {
+                    type: "string";
+                    enum: readonly ["created_at", "updated_at"];
+                    default: string;
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'get-record-details': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+                fields: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+            };
+            required: ("record_id" | "resource_type")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'create-record': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_data: {
+                    type: "object";
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                return_details: {
+                    type: "boolean";
+                    default: boolean;
+                    description: string;
+                };
+            };
+            required: ("resource_type" | "record_data")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    'update-record': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+                record_data: {
+                    type: "object";
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                return_details: {
+                    type: "boolean";
+                    default: boolean;
+                    description: string;
+                };
+            };
+            required: ("record_id" | "resource_type" | "record_data")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    'delete-record': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("record_id" | "resource_type")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    'get-attributes': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+                categories: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+                fields: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'discover-attributes': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                categories: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'get-detailed-info': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("record_id" | "resource_type")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'create-note': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+                title: {
+                    type: "string";
+                    description: string;
+                };
+                content: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("record_id" | "title" | "content" | "resource_type")[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    'list-notes': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    enum: import("./types.js").UniversalResourceType[];
+                    description: string;
+                };
+                record_id: {
+                    type: "string";
+                    description: string;
+                };
+                parent_record_id: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'aaa-health-check': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {};
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    'health-check': {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: string;
+            properties: {};
+            additionalProperties: boolean;
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+};
+/**
+ * Core universal operations (8 tools)
+ * These consolidate the majority of CRUD and basic search operations
+ */
+export declare const coreUniversalTools: string[];
+/**
+ * Advanced universal operations (6 tools)
+ * These provide sophisticated search and batch capabilities
+ */
+export declare const advancedUniversalTools: string[];
+/**
+ * All universal tool names
+ */
+export declare const allUniversalTools: string[];
+/**
+ * Tools that will be deprecated and replaced by universal operations
+ *
+ * These mappings help with migration and alias creation
+ */
+export declare const deprecatedToolMappings: Record<string, string>;
+/**
+ * Resource type mappings for deprecated tools
+ * Used to automatically set resource_type when migrating from old tools
+ */
+export declare const resourceTypeMappings: Record<string, string>;
+/**
+ * Info type mappings for get-detailed-info universal tool
+ */
+export declare const infoTypeMappings: Record<string, string>;
+/**
+ * Content type mappings for search-by-content universal tool
+ */
+export declare const contentTypeMappings: Record<string, string>;
+/**
+ * Timeframe type mappings for search-by-timeframe universal tool
+ */
+export declare const timeframeTypeMappings: Record<string, string>;
+/**
+ * Relationship type mappings for search-by-relationship universal tool
+ */
+export declare const relationshipTypeMappings: Record<string, string>;
+/**
+ * Batch operation type mappings for batch-operations universal tool
+ */
+export declare const batchOperationTypeMappings: Record<string, string>;
+/**
+ * Get the count of tools that will be consolidated
+ */
+export declare function getConsolidationStats(): {
+    deprecatedCount: number;
+    universalCount: number;
+    reductionCount: number;
+    reductionPercentage: number;
+    summary: string;
+};
+/**
+ * Utility to check if a tool name is a universal tool
+ */
+export declare function isUniversalTool(toolName: string): boolean;
+/**
+ * Utility to check if a tool name is deprecated and should be migrated
+ */
+export declare function isDeprecatedTool(toolName: string): boolean;
+/**
+ * Get the universal tool equivalent for a deprecated tool
+ */
+export declare function getUniversalEquivalent(deprecatedToolName: string): string | undefined;
+/**
+ * Get migration parameters for converting a deprecated tool call to universal
+ */
+export declare function getMigrationParams(deprecatedToolName: string, originalParams: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Log consolidation statistics
+ */
+export declare function logConsolidationStats(): Promise<void>;
+//# sourceMappingURL=index.d.ts.map