@iflow-mcp/attio-mcp 1.3.6

package/dist/handlers/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/handlers/tools/registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAMtD,KAAK,gBAAgB,GAAG;IACtB,YAAY,EAAE,YAAY,GAAG,WAAW,GAAG,SAAS,CAAC;IACrD,UAAU,EAAE,UAAU,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA4DF;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBpB,CAAC;AAEN;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBxB,CAAC;AAEN;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CA2I7E"}

package/dist/handlers/tools/registry.js

@@ -0,0 +1,206 @@
+/**
+ * Tool registry module - handles tool registration mechanics and discovery
+ */
+import { ResourceType } from '../../types/attio.js';
+import { createScopedLogger } from '../../utils/logger.js';
+import { isToolAllowed } from '../../config/tool-mode.js';
+import { resolveToolName } from '../../config/tool-aliases.js';
+// Import consolidated tool configurations from modular files
+import { companyToolConfigs, companyToolDefinitions, } from '../../handlers/tool-configs/companies/index.js';
+import { peopleToolConfigs, peopleToolDefinitions, } from '../../handlers/tool-configs/people/index.js';
+import { dealToolConfigs, dealToolDefinitions, } from '../../handlers/tool-configs/deals/index.js';
+import { listsToolConfigs, listsToolDefinitions, } from '../../handlers/tool-configs/lists.js';
+import { tasksToolConfigs, tasksToolDefinitions, } from '../../handlers/tool-configs/tasks.js';
+import { recordToolConfigs, recordToolDefinitions, } from '../../handlers/tool-configs/records/index.js';
+import { generalToolConfigs, generalToolDefinitions, } from '../../handlers/tool-configs/general/index.js';
+import { workspaceMembersToolConfigs, workspaceMembersToolDefinitions, } from '../../handlers/tool-configs/workspace-members.js';
+// Import universal tool configurations for consolidated operations
+import { universalToolConfigs, universalToolDefinitions, } from '../../handlers/tool-configs/universal/index.js';
+/**
+ * Universal tool consolidation (Issue #352): Only expose universal tools
+ * This replaces the legacy resource-specific tools with consolidated universal tools
+ * that can handle all resource types (companies, people, records, tasks) through
+ * a single, consistent interface.
+ *
+ * Legacy tools are kept for backward compatibility but not exposed by default.
+ */
+const USE_UNIVERSAL_TOOLS_ONLY = process.env.DISABLE_UNIVERSAL_TOOLS !== 'true';
+// Issue #1022: Deprecation warning for legacy tools
+// Gate warning to avoid test noise (module-load side effect)
+if (!USE_UNIVERSAL_TOOLS_ONLY && process.env.NODE_ENV !== 'test') {
+    createScopedLogger('tools', 'registry').warn('Legacy tools (DISABLE_UNIVERSAL_TOOLS=true) are deprecated and will be removed in v2.0.0 (Q1 2026). See docs/MIGRATION-GUIDE.md');
+}
+/**
+ * Consolidated tool configurations from modular files
+ */
+export const TOOL_CONFIGS = USE_UNIVERSAL_TOOLS_ONLY
+    ? {
+        // Universal tools for consolidated operations (Issue #352)
+        UNIVERSAL: universalToolConfigs,
+        // Lists are relationship containers - always expose them (Issue #470)
+        [ResourceType.LISTS]: listsToolConfigs,
+        // Workspace members for user discovery (Issue #684)
+        [ResourceType.WORKSPACE_MEMBERS]: workspaceMembersToolConfigs,
+    }
+    : {
+        // Legacy resource-specific tools (deprecated, use DISABLE_UNIVERSAL_TOOLS=true to enable)
+        [ResourceType.COMPANIES]: companyToolConfigs,
+        [ResourceType.PEOPLE]: peopleToolConfigs,
+        [ResourceType.DEALS]: dealToolConfigs,
+        [ResourceType.LISTS]: listsToolConfigs,
+        [ResourceType.TASKS]: tasksToolConfigs,
+        [ResourceType.RECORDS]: recordToolConfigs,
+        [ResourceType.WORKSPACE_MEMBERS]: workspaceMembersToolConfigs,
+        GENERAL: generalToolConfigs,
+        // Add other resource types as needed
+    };
+/**
+ * Consolidated tool definitions from modular files
+ */
+export const TOOL_DEFINITIONS = USE_UNIVERSAL_TOOLS_ONLY
+    ? {
+        // Universal tools for consolidated operations (Issue #352)
+        UNIVERSAL: universalToolDefinitions,
+        // Lists are relationship containers - always expose them (Issue #470)
+        [ResourceType.LISTS]: listsToolDefinitions,
+        // Workspace members for user discovery (Issue #684)
+        [ResourceType.WORKSPACE_MEMBERS]: workspaceMembersToolDefinitions,
+    }
+    : {
+        // Legacy resource-specific tools (deprecated, use DISABLE_UNIVERSAL_TOOLS=true to enable)
+        [ResourceType.COMPANIES]: companyToolDefinitions,
+        [ResourceType.PEOPLE]: peopleToolDefinitions,
+        [ResourceType.DEALS]: dealToolDefinitions,
+        [ResourceType.LISTS]: listsToolDefinitions,
+        [ResourceType.TASKS]: tasksToolDefinitions,
+        [ResourceType.RECORDS]: recordToolDefinitions,
+        [ResourceType.WORKSPACE_MEMBERS]: workspaceMembersToolDefinitions,
+        GENERAL: generalToolDefinitions,
+        // Add other resource types as needed
+    };
+/**
+ * Find the tool config for a given tool name
+ *
+ * @param toolName - The name of the tool
+ * @returns Tool configuration or undefined if not found
+ */
+export function findToolConfig(toolName) {
+    // Debug logging for tool lookup in development
+    const debugMode = process.env.NODE_ENV === 'development' || process.env.DEBUG;
+    // Debug logging for all tool lookups in development
+    const log = createScopedLogger('tools.registry', 'findToolConfig');
+    if (debugMode) {
+        log.debug(`Looking for tool: ${toolName}`);
+    }
+    const { name: canonicalToolName } = resolveToolName(toolName);
+    // Search in resource-specific tools first
+    for (const resourceType of Object.values(ResourceType)) {
+        const resourceConfig = TOOL_CONFIGS[resourceType];
+        if (!resourceConfig) {
+            if (debugMode) {
+                log.debug(`No config found for resource type: ${resourceType}`);
+            }
+            continue;
+        }
+        // For debugging, log all available tools for a resource type
+        if (debugMode) {
+            const toolTypes = Object.keys(resourceConfig);
+            if (toolTypes.includes(canonicalToolName.replace(/-/g, ''))) {
+                log.info('Tool might be found under a different name. Available tool types', { toolTypes });
+            }
+            // Specific logging for commonly problematic tools
+            const commonProblematicTools = [
+                'discover-company-attributes',
+                'get-company-basic-info',
+            ];
+            if (commonProblematicTools.includes(canonicalToolName) &&
+                resourceType === ResourceType.COMPANIES) {
+                const toolTypeKey = canonicalToolName === 'discover-company-attributes'
+                    ? 'discoverAttributes'
+                    : 'basicInfo';
+                // Use a type-safe way to check for existence
+                const hasToolType = Object.keys(resourceConfig).includes(toolTypeKey);
+                if (hasToolType) {
+                    const config = resourceConfig[toolTypeKey];
+                    log.info('Found config for legacy mapping', {
+                        toolTypeKey,
+                        name: config.name,
+                        hasHandler: typeof config.handler === 'function',
+                        hasFormatter: typeof config.formatResult === 'function',
+                    });
+                }
+                else {
+                    log.warn(`${toolTypeKey} not found in ${resourceType} configs`);
+                }
+            }
+        }
+        for (const [toolType, config] of Object.entries(resourceConfig)) {
+            if (config && config.name === canonicalToolName) {
+                if (debugMode) {
+                    log.info('Found tool in resource config', {
+                        toolName: canonicalToolName,
+                        toolType,
+                        resourceType,
+                    });
+                }
+                if (isToolAllowed(canonicalToolName)) {
+                    return {
+                        resourceType: resourceType,
+                        toolConfig: config,
+                        toolType,
+                    };
+                }
+                return undefined;
+            }
+        }
+    }
+    // Search in universal tools (high priority for consolidation)
+    const universalConfig = TOOL_CONFIGS.UNIVERSAL;
+    if (universalConfig) {
+        for (const [toolType, config] of Object.entries(universalConfig)) {
+            if (config && config.name === canonicalToolName) {
+                if (debugMode) {
+                    log.info('Found universal tool', {
+                        toolName: canonicalToolName,
+                        toolType,
+                    });
+                }
+                if (isToolAllowed(canonicalToolName)) {
+                    return {
+                        resourceType: 'UNIVERSAL',
+                        toolConfig: config,
+                        toolType,
+                    };
+                }
+                return undefined;
+            }
+        }
+    }
+    // Search in general tools if not found in resource-specific or universal tools
+    const generalConfig = TOOL_CONFIGS.GENERAL;
+    if (generalConfig) {
+        for (const [toolType, config] of Object.entries(generalConfig)) {
+            if (config && config.name === canonicalToolName) {
+                if (debugMode) {
+                    log.info('Found general tool', {
+                        toolName: canonicalToolName,
+                        toolType,
+                    });
+                }
+                if (isToolAllowed(canonicalToolName)) {
+                    return {
+                        resourceType: 'GENERAL',
+                        toolConfig: config,
+                        toolType,
+                    };
+                }
+                return undefined;
+            }
+        }
+    }
+    if (debugMode) {
+        log.warn('Tool not found', { toolName: canonicalToolName });
+    }
+    return undefined;
+}
+//# sourceMappingURL=registry.js.map

package/dist/handlers/tools/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../src/handlers/tools/registry.ts"],"names":[],"mappings":"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"}

package/dist/handlers/tools/standards/index.d.ts

@@ -0,0 +1,17 @@
+export declare const TOOL_NAME_TEMPLATE = "<resource>.<action>";
+export interface ToolDescriptionTemplateOptions {
+    capability: string;
+    boundaries: string;
+    constraints?: string;
+    requiresApproval?: boolean;
+    recoveryHint?: string;
+}
+export declare function formatToolDescription(options: ToolDescriptionTemplateOptions): string;
+export interface ErrorTemplateOptions {
+    code: number;
+    message: string;
+    recovery?: string;
+    docs?: string;
+}
+export declare function buildErrorTemplate(options: ErrorTemplateOptions): Record<string, unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/tools/standards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/handlers/tools/standards/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AAExD,MAAM,WAAW,8BAA8B;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,8BAA8B,GACtC,MAAM,CAqCR;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAOzB"}

package/dist/handlers/tools/standards/index.js

@@ -0,0 +1,40 @@
+export const TOOL_NAME_TEMPLATE = '<resource>.<action>'; // verb-first pattern
+export function formatToolDescription(options) {
+    const sentences = [];
+    // Primary capability - ensure it ends with a period
+    const capability = options.capability.trim();
+    sentences.push(capability.endsWith('.') ? capability : `${capability}.`);
+    // Safety/boundaries - what it does NOT do
+    if (options.boundaries) {
+        const boundaries = options.boundaries.trim();
+        sentences.push(boundaries.startsWith('Never ') || boundaries.startsWith('Does not ')
+            ? boundaries.endsWith('.')
+                ? boundaries
+                : `${boundaries}.`
+            : `Never ${boundaries.endsWith('.') ? boundaries : `${boundaries}.`}`);
+    }
+    // Approval flag (if write operation)
+    if (options.requiresApproval) {
+        sentences.push('May require explicit user approval from the host.');
+    }
+    // Constraints (limits/requirements)
+    if (options.constraints) {
+        const constraints = options.constraints.trim();
+        sentences.push(constraints.endsWith('.') ? constraints : `${constraints}.`);
+    }
+    // Recovery hint (fallback action)
+    if (options.recoveryHint) {
+        const hint = options.recoveryHint.trim();
+        sentences.push(hint.endsWith('.') ? hint : `${hint}.`);
+    }
+    return sentences.join(' ');
+}
+export function buildErrorTemplate(options) {
+    return {
+        code: options.code,
+        message: options.message,
+        recovery: options.recovery,
+        docs: options.docs,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/handlers/tools/standards/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/handlers/tools/standards/index.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,qBAAqB,CAAC,CAAC,qBAAqB;AAU9E,MAAM,UAAU,qBAAqB,CACnC,OAAuC;IAEvC,MAAM,SAAS,GAAa,EAAE,CAAC;IAE/B,oDAAoD;IACpD,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;IAC7C,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,CAAC,CAAC;IAEzE,0CAA0C;IAC1C,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;QACvB,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;QAC7C,SAAS,CAAC,IAAI,CACZ,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,WAAW,CAAC;YACnE,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC;gBACxB,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,GAAG,UAAU,GAAG;YACpB,CAAC,CAAC,SAAS,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,GAAG,EAAE,CACxE,CAAC;IACJ,CAAC;IAED,qCAAqC;IACrC,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;QAC7B,SAAS,CAAC,IAAI,CAAC,mDAAmD,CAAC,CAAC;IACtE,CAAC;IAED,oCAAoC;IACpC,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;QACxB,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC;QAC/C,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,GAAG,CAAC,CAAC;IAC9E,CAAC;IAED,kCAAkC;IAClC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QACzC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;IACzD,CAAC;IAED,OAAO,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC7B,CAAC;AASD,MAAM,UAAU,kBAAkB,CAChC,OAA6B;IAE7B,OAAO;QACL,IAAI,EAAE,OAAO,CAAC,IAAI;QAClB,OAAO,EAAE,OAAO,CAAC,OAAO;QACxB,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;KACnB,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Library entrypoint for Attio MCP Server
+ *
+ * This file exports reusable components for import by other modules.
+ * It contains NO side effects, CLI argument parsing, or process.exit() calls.
+ * This ensures it's safe to import from Smithery's metadata extraction process.
+ */
+export { createServer } from './server/createServer.js';
+export { configSchema } from './smithery.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAGxD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+/**
+ * Library entrypoint for Attio MCP Server
+ *
+ * This file exports reusable components for import by other modules.
+ * It contains NO side effects, CLI argument parsing, or process.exit() calls.
+ * This ensures it's safe to import from Smithery's metadata extraction process.
+ */
+// Guard to prevent direct execution (forces use of CLI entry point)
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const { error } = await import('./utils/logger.js');
+    error('library-entry', 'This is a library entry point. Use the CLI instead', undefined, {
+        suggestion: 'node dist/cli.js or attio-mcp (if installed globally)',
+    });
+    process.exit(1);
+}
+// Export the main server creation function for use by CLI and Smithery
+export { createServer } from './server/createServer.js';
+// Export configuration schema for external tools
+export { configSchema } from './smithery.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,oEAAoE;AACpE,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,KAAK,UAAU,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;IACpD,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,CAAC;IACpD,KAAK,CACH,eAAe,EACf,oDAAoD,EACpD,SAAS,EACT;QACE,UAAU,EAAE,uDAAuD;KACpE,CACF,CAAC;IACF,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC;AAED,uEAAuE;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,iDAAiD;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC"}

package/dist/lib/http/toMcpResult.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Centralized HTTP → MCP error mapping
+ * Converts HTTP responses to MCP-compliant result format
+ */
+export interface HttpResponse {
+    status: number;
+    body: unknown;
+}
+export interface McpResult {
+    isError: boolean;
+    content?: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    error?: {
+        code: number;
+        type: string;
+        message?: string;
+    };
+}
+/**
+ * Convert HTTP response to MCP-compliant result format
+ * Non-2xx responses become isError: true with appropriate error messages
+ */
+export declare function toMcpResult(resp: HttpResponse): McpResult;
+/**
+ * Check if a result looks like an HTTP response
+ */
+export declare function isHttpResponseLike(result: unknown): result is HttpResponse;
+//# sourceMappingURL=toMcpResult.d.ts.map

package/dist/lib/http/toMcpResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMcpResult.d.ts","sourceRoot":"","sources":["../../../src/lib/http/toMcpResult.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,YAAY,GAAG,SAAS,CAmDzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,YAAY,CAQ1E"}

package/dist/lib/http/toMcpResult.js

@@ -0,0 +1,62 @@
+/**
+ * Centralized HTTP → MCP error mapping
+ * Converts HTTP responses to MCP-compliant result format
+ */
+/**
+ * Convert HTTP response to MCP-compliant result format
+ * Non-2xx responses become isError: true with appropriate error messages
+ */
+export function toMcpResult(resp) {
+    const responseBody = typeof resp.body === 'object' && resp.body !== null
+        ? resp.body
+        : {};
+    if (resp.status >= 200 && resp.status < 300) {
+        return {
+            isError: false,
+            content: [{ type: 'text', text: JSON.stringify(resp.body) }],
+        };
+    }
+    // Check if we have a structured error with code and type
+    if ('code' in responseBody && 'type' in responseBody) {
+        return {
+            isError: true,
+            error: {
+                code: resp.status,
+                type: String(responseBody.type),
+                message: responseBody.message,
+            },
+            content: [
+                {
+                    type: 'text',
+                    text: responseBody.message ||
+                        `HTTP ${resp.status}`,
+                },
+            ],
+        };
+    }
+    // Fallback to simple message format
+    const msg = responseBody.message ||
+        (typeof responseBody.error === 'object' && responseBody.error !== null
+            ? responseBody.error.message
+            : undefined) ||
+        (resp.status === 404
+            ? 'record not found'
+            : resp.status === 400
+                ? 'invalid record_id format'
+                : `HTTP ${resp.status}`);
+    return {
+        isError: true,
+        content: [{ type: 'text', text: msg }],
+    };
+}
+/**
+ * Check if a result looks like an HTTP response
+ */
+export function isHttpResponseLike(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'status' in result &&
+        typeof result.status === 'number' &&
+        'body' in result);
+}
+//# sourceMappingURL=toMcpResult.js.map

package/dist/lib/http/toMcpResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toMcpResult.js","sourceRoot":"","sources":["../../../src/lib/http/toMcpResult.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiBH;;;GAGG;AACH,MAAM,UAAU,WAAW,CAAC,IAAkB;IAC5C,MAAM,YAAY,GAChB,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI;QACjD,CAAC,CAAE,IAAI,CAAC,IAAgC;QACxC,CAAC,CAAC,EAAE,CAAC;IAET,IAAI,IAAI,CAAC,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;QAC5C,OAAO;YACL,OAAO,EAAE,KAAK;YACd,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;SAC7D,CAAC;IACJ,CAAC;IAED,yDAAyD;IACzD,IAAI,MAAM,IAAI,YAAY,IAAI,MAAM,IAAI,YAAY,EAAE,CAAC;QACrD,OAAO;YACL,OAAO,EAAE,IAAI;YACb,KAAK,EAAE;gBACL,IAAI,EAAE,IAAI,CAAC,MAAM;gBACjB,IAAI,EAAE,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC;gBAC/B,OAAO,EAAE,YAAY,CAAC,OAA6B;aACpD;YACD,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EACD,YAAY,CAAC,OAA8B;wBAC5C,QAAQ,IAAI,CAAC,MAAM,EAAE;iBACxB;aACF;SACF,CAAC;IACJ,CAAC;IAED,oCAAoC;IACpC,MAAM,GAAG,GACN,YAAY,CAAC,OAA8B;QAC5C,CAAC,OAAO,YAAY,CAAC,KAAK,KAAK,QAAQ,IAAI,YAAY,CAAC,KAAK,KAAK,IAAI;YACpE,CAAC,CAAG,YAAY,CAAC,KAAiC,CAAC,OAEnC;YAChB,CAAC,CAAC,SAAS,CAAC;QACd,CAAC,IAAI,CAAC,MAAM,KAAK,GAAG;YAClB,CAAC,CAAC,kBAAkB;YACpB,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,GAAG;gBACnB,CAAC,CAAC,0BAA0B;gBAC5B,CAAC,CAAC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;IAE/B,OAAO;QACL,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;KACvC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,kBAAkB,CAAC,MAAe;IAChD,OAAO,CACL,OAAO,MAAM,KAAK,QAAQ;QAC1B,MAAM,KAAK,IAAI;QACf,QAAQ,IAAI,MAAM;QAClB,OAAQ,MAA+B,CAAC,MAAM,KAAK,QAAQ;QAC3D,MAAM,IAAI,MAAM,CACjB,CAAC;AACJ,CAAC"}

package/dist/middleware/performance-compat.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Performance Monitor Compatibility Layer
+ *
+ * Provides instance-based singleton API for legacy tests while using
+ * the improved static PerformanceTracker implementation.
+ */
+import { PerformanceMetrics, PerformanceSummary } from './performance.js';
+/**
+ * Instance-based wrapper for PerformanceTracker static methods
+ */
+declare class PerformanceMonitorInstance {
+    private static _instance;
+    private activeOperations;
+    static getInstance(): PerformanceMonitorInstance;
+    startOperation(toolName: string, metadata?: Record<string, unknown>): number;
+    endOperation(toolName: string, startTimeOrSuccess?: number | boolean, success?: boolean, error?: string, metadata?: Record<string, unknown>): PerformanceMetrics;
+    getSummary(toolName?: string): PerformanceSummary;
+    clear(): void;
+    reset(): void;
+    getMetrics(): {
+        totalOperations: number;
+        averageTime: number;
+        slowOperations: number;
+    };
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    measureAsync<T>(toolName: string, fn: () => Promise<T>, metadata?: Record<string, unknown>): Promise<T>;
+    measure<T>(toolName: string, fn: () => T, metadata?: Record<string, unknown>): T;
+    getSlowOperations(threshold?: number): PerformanceMetrics[];
+    getFailedOperations(): PerformanceMetrics[];
+    generateReport(): string;
+}
+/**
+ * Singleton PerformanceMonitor for backward compatibility
+ */
+export declare const PerformanceMonitor: typeof PerformanceMonitorInstance;
+export declare const performanceMonitor: PerformanceMonitorInstance;
+export {};
+//# sourceMappingURL=performance-compat.d.ts.map

package/dist/middleware/performance-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-compat.d.ts","sourceRoot":"","sources":["../../src/middleware/performance-compat.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,cAAM,0BAA0B;IAC9B,OAAO,CAAC,MAAM,CAAC,SAAS,CAAyC;IACjE,OAAO,CAAC,gBAAgB,CAAkC;IAE1D,MAAM,CAAC,WAAW,IAAI,0BAA0B;IAQhD,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAM5E,YAAY,CACV,QAAQ,EAAE,MAAM,EAChB,kBAAkB,CAAC,EAAE,MAAM,GAAG,OAAO,EACrC,OAAO,GAAE,OAAc,EACvB,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,kBAAkB;IA+CrB,UAAU,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,kBAAkB;IAIjD,KAAK,IAAI,IAAI;IAKb,KAAK,IAAI,IAAI;IAMb,UAAU,IAAI;QACZ,eAAe,EAAE,MAAM,CAAC;QACxB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;KACxB;IAWD,SAAS,IAAI,OAAO;IAIpB,UAAU,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAI5B,YAAY,CAAC,CAAC,EAClB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,CAAC,CAAC;IAIb,OAAO,CAAC,CAAC,EACP,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,CAAC,EACX,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,CAAC;IAIJ,iBAAiB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,kBAAkB,EAAE;IAI3D,mBAAmB,IAAI,kBAAkB,EAAE;IAI3C,cAAc,IAAI,MAAM;CAGzB;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,mCAA6B,CAAC;AAG7D,eAAO,MAAM,kBAAkB,4BAA2C,CAAC"}

package/dist/middleware/performance-compat.js

@@ -0,0 +1,110 @@
+/**
+ * Performance Monitor Compatibility Layer
+ *
+ * Provides instance-based singleton API for legacy tests while using
+ * the improved static PerformanceTracker implementation.
+ */
+import { PerformanceTracker, } from './performance.js';
+/**
+ * Instance-based wrapper for PerformanceTracker static methods
+ */
+class PerformanceMonitorInstance {
+    static _instance;
+    activeOperations = new Map();
+    static getInstance() {
+        if (!this._instance) {
+            this._instance = new PerformanceMonitorInstance();
+        }
+        return this._instance;
+    }
+    // Instance methods that delegate to static PerformanceTracker methods
+    startOperation(toolName, metadata) {
+        const startTime = PerformanceTracker.startOperation(toolName, metadata);
+        this.activeOperations.set(toolName, startTime);
+        return startTime;
+    }
+    endOperation(toolName, startTimeOrSuccess, success = true, error, metadata) {
+        // Support both patterns:
+        // 1. endOperation(toolName, startTime, success, error, metadata) - explicit startTime
+        // 2. endOperation(toolName, success, error, metadata) - use stored startTime
+        let startTime;
+        let actualSuccess;
+        let actualError;
+        let actualMetadata;
+        if (typeof startTimeOrSuccess === 'number') {
+            // Pattern 1: explicit startTime provided
+            startTime = startTimeOrSuccess;
+            actualSuccess = success;
+            actualError = error;
+            actualMetadata = metadata;
+        }
+        else {
+            // Pattern 2: use stored startTime
+            const storedStartTime = this.activeOperations.get(toolName);
+            if (storedStartTime === undefined) {
+                throw new Error(`No active operation found for tool: ${toolName}. Call startOperation() first.`);
+            }
+            startTime = storedStartTime;
+            actualSuccess =
+                typeof startTimeOrSuccess === 'boolean' ? startTimeOrSuccess : true;
+            actualError =
+                typeof success === 'string' ? success : error;
+            actualMetadata =
+                error && typeof error === 'object'
+                    ? error
+                    : metadata;
+            // Clean up stored operation
+            this.activeOperations.delete(toolName);
+        }
+        return PerformanceTracker.endOperation(toolName, startTime, actualSuccess, actualError, actualMetadata);
+    }
+    getSummary(toolName) {
+        return PerformanceTracker.getSummary(toolName);
+    }
+    clear() {
+        this.activeOperations.clear();
+        return PerformanceTracker.clear();
+    }
+    reset() {
+        // Alias for clear() to match legacy test expectations
+        this.activeOperations.clear();
+        return PerformanceTracker.clear();
+    }
+    getMetrics() {
+        const summary = PerformanceTracker.getSummary();
+        const slowOps = PerformanceTracker.getSlowOperations(100);
+        return {
+            totalOperations: summary.totalOperations,
+            averageTime: summary.averageDuration,
+            slowOperations: slowOps.length,
+        };
+    }
+    isEnabled() {
+        return PerformanceTracker.isEnabled();
+    }
+    setEnabled(enabled) {
+        return PerformanceTracker.setEnabled(enabled);
+    }
+    async measureAsync(toolName, fn, metadata) {
+        return PerformanceTracker.measureAsync(toolName, fn, metadata);
+    }
+    measure(toolName, fn, metadata) {
+        return PerformanceTracker.measure(toolName, fn, metadata);
+    }
+    getSlowOperations(threshold) {
+        return PerformanceTracker.getSlowOperations(threshold);
+    }
+    getFailedOperations() {
+        return PerformanceTracker.getFailedOperations();
+    }
+    generateReport() {
+        return PerformanceTracker.generateReport();
+    }
+}
+/**
+ * Singleton PerformanceMonitor for backward compatibility
+ */
+export const PerformanceMonitor = PerformanceMonitorInstance;
+// Export the instance for direct usage
+export const performanceMonitor = PerformanceMonitorInstance.getInstance();
+//# sourceMappingURL=performance-compat.js.map

package/dist/middleware/performance-compat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-compat.js","sourceRoot":"","sources":["../../src/middleware/performance-compat.ts"],"names":[],"mappings":"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"}