attio-mcp 1.3.6 → 1.4.1

package/dist/handlers/tool-configs/universal/core/error-enhancers/select-status-enhancer.js

@@ -0,0 +1,118 @@
+/**
+ * Select/Status Error Enhancer
+ * Issue #1001 - Strategy Pattern for CRUD error handling
+ *
+ * Detects "Cannot find select option" or "Cannot find Status" errors
+ * and provides valid options from AttributeOptionsService.
+ */
+import { getErrorMessage, isAxiosError } from './types.js';
+import { sanitizedLog } from '../pii-sanitizer.js';
+import { createScopedLogger } from '../../../../../utils/logger.js';
+const logger = createScopedLogger('select-status-enhancer');
+/**
+ * Enhance error messages for select/status attribute errors
+ */
+const enhanceSelectStatusError = async (error, resourceType, recordData) => {
+    const msg = getErrorMessage(error);
+    // Attempt to extract validation_errors array for better detail on select fields
+    if (isAxiosError(error)) {
+        const validationErrors = error.response?.data?.validation_errors;
+        if (validationErrors) {
+            const selectErr = validationErrors.find((ve) => String(ve?.message || '').includes('select option'));
+            if (selectErr?.field) {
+                try {
+                    const { AttributeOptionsService } = await import('../../../../../services/metadata/index.js');
+                    const { options, attributeType } = await AttributeOptionsService.getOptions(resourceType, selectErr.field);
+                    const validList = options
+                        .slice(0, 8)
+                        .map((o) => o.title)
+                        .join(', ');
+                    const hasMore = options.length > 8 ? ` (+${options.length - 8} more)` : '';
+                    return `Value is not valid for ${attributeType} attribute "${selectErr.field}" on ${resourceType}.
+Expected one of: ${validList}${hasMore}
+
+Next step: Call records_get_attribute_options with
+  resource_type: "${resourceType}"
+  attribute: "${selectErr.field}"
+to list all valid values, then retry.`;
+                }
+                catch (err) {
+                    sanitizedLog(logger, 'debug', 'Failed to fetch select/status options for enhanced error message', {
+                        enhancerName: 'select-status',
+                        resourceType,
+                        attribute: selectErr.field,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                    return `Value is not valid for attribute "${selectErr.field}" on ${resourceType}.
+Next step: Call records_get_attribute_options with
+  resource_type: "${resourceType}"
+  attribute: "${selectErr.field}"
+to see valid options, then retry.`;
+                }
+            }
+        }
+    }
+    // Pattern: "Cannot find select option with title 'X'" or "Cannot find Status with title 'X'"
+    const selectMatch = msg.match(/Cannot find (?:select option|Status) with title "(.+?)"/);
+    if (!selectMatch)
+        return null;
+    const invalidValue = selectMatch[1];
+    // Try to identify which field has the problem by checking record data
+    for (const [fieldName, fieldValue] of Object.entries(recordData)) {
+        if (fieldValue === invalidValue ||
+            (Array.isArray(fieldValue) && fieldValue.includes(invalidValue))) {
+            try {
+                const { AttributeOptionsService } = await import('../../../../../services/metadata/index.js');
+                const { options, attributeType } = await AttributeOptionsService.getOptions(resourceType, fieldName);
+                const validList = options
+                    .slice(0, 8)
+                    .map((o) => o.title)
+                    .join(', ');
+                const hasMore = options.length > 8 ? ` (+${options.length - 8} more)` : '';
+                return (`Value "${invalidValue}" is not valid for ${attributeType} attribute "${fieldName}" on ${resourceType}.\n\n` +
+                    `Valid options: ${validList}${hasMore}\n\n` +
+                    `Next step: Call records_get_attribute_options with\n` +
+                    `  resource_type: "${resourceType}"\n` +
+                    `  attribute: "${fieldName}"\n` +
+                    `to list all valid values, then retry.`);
+            }
+            catch (err) {
+                sanitizedLog(logger, 'debug', 'Failed to fetch attribute options (no invalid value extracted)', {
+                    enhancerName: 'select-status',
+                    resourceType,
+                    attribute: fieldName,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return (`Value "${invalidValue}" is not valid for attribute "${fieldName}" on ${resourceType}.\n\n` +
+                    `Next step: Call records_get_attribute_options with\n` +
+                    `  resource_type: "${resourceType}"\n` +
+                    `  attribute: "${fieldName}"\n` +
+                    `to see valid options, then retry.`);
+            }
+        }
+    }
+    // Couldn't match to a specific field, return generic hint
+    return (`Value "${invalidValue}" is not valid for an attribute on ${resourceType}.\n\n` +
+        `Next step: Use records_get_attribute_options to discover valid options for the attribute.`);
+};
+/**
+ * Select/Status Enhancer
+ * Provides valid options for select and status field errors
+ */
+export const selectStatusEnhancer = {
+    name: 'select-status',
+    errorName: 'value_not_found',
+    matches: (error, _context) => {
+        const msg = getErrorMessage(error);
+        return (msg.includes('Cannot find select option') ||
+            msg.includes('Cannot find Status') ||
+            msg.includes('select option'));
+    },
+    enhance: async (error, context) => {
+        const { resourceType, recordData } = context;
+        if (!recordData)
+            return null;
+        return enhanceSelectStatusError(error, resourceType, recordData);
+    },
+};
+//# sourceMappingURL=select-status-enhancer.js.map

package/dist/handlers/tool-configs/universal/core/error-enhancers/select-status-enhancer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-status-enhancer.js","sourceRoot":"","sources":["../../../../../../src/handlers/tool-configs/universal/core/error-enhancers/select-status-enhancer.ts"],"names":[],"mappings":"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"}

package/dist/handlers/tool-configs/universal/core/error-enhancers/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Error Enhancer Strategy Pattern Types
+ * Issue #1001 - Refactoring crud-error-handlers.ts
+ */
+import type { ValidationMetadata } from '../../../../../handlers/tool-configs/universal/core/utils.js';
+/**
+ * Context passed to error enhancers
+ */
+export interface CrudErrorContext {
+    readonly operation: 'create' | 'update' | 'delete' | 'search';
+    readonly resourceType: string;
+    readonly recordData?: Readonly<Record<string, unknown>>;
+    readonly recordId?: string;
+    readonly validationMetadata?: Readonly<ValidationMetadata>;
+}
+/**
+ * Strategy interface for error enhancement
+ * Each enhancer implements pattern matching and message enhancement
+ */
+export interface ErrorEnhancer {
+    /** Unique name for the enhancer */
+    readonly name: string;
+    /** Check if this enhancer can handle the error */
+    readonly matches: (error: unknown, context: CrudErrorContext) => boolean;
+    /** Enhance the error message with context-specific details */
+    readonly enhance: (error: unknown, context: CrudErrorContext) => Promise<string | null>;
+    /** Error name to use when throwing the enhanced error */
+    readonly errorName: string;
+}
+/**
+ * Extract error message from Error instances, axios-style errors, or test mocks
+ *
+ * Handles three cases:
+ * 1. Real Error instances: returns error.message
+ * 2. Error-like objects (axios/mocks): extracts message property
+ * 3. Primitive values: converts to string
+ *
+ * This helper was added to fix test compatibility issues where test mocks
+ * aren't true Error instances but have message properties. It provides a
+ * consistent way to extract error messages across production code and tests.
+ *
+ * @param error - Any error value (Error, axios error object, string, etc.)
+ * @returns Error message as string (never null/undefined)
+ *
+ * @example
+ * getErrorMessage(new Error("test")) // "test"
+ * getErrorMessage({ message: "axios error" }) // "axios error"
+ * getErrorMessage("string error") // "string error"
+ */
+export declare const getErrorMessage: (error: unknown) => string;
+/**
+ * Axios-style error response structure
+ * Used for type-safe extraction of validation errors from Attio API responses
+ */
+export interface AxiosErrorResponse {
+    data?: {
+        message?: string;
+        validation_errors?: Array<{
+            field?: string;
+            path?: string;
+            message?: string;
+        }>;
+    };
+}
+/**
+ * Axios error with response
+ * Allows type-safe access to error.response.data.validation_errors
+ */
+export interface AxiosError extends Error {
+    response?: AxiosErrorResponse;
+}
+/**
+ * Type guard to check if error is an Axios error
+ */
+export declare function isAxiosError(error: unknown): error is AxiosError;
+export type { ValidationMetadata };
+//# sourceMappingURL=types.d.ts.map

package/dist/handlers/tool-configs/universal/core/error-enhancers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/handlers/tool-configs/universal/core/error-enhancers/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAE1F;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,SAAS,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,CAAC,EAAE,QAAQ,CAAC,kBAAkB,CAAC,CAAC;CAC5D;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,KAAK,OAAO,CAAC;IAEzE,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,CAChB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,gBAAgB,KACtB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAE5B,yDAAyD;IACzD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,OAAO,KAAG,MAMhD,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,iBAAiB,CAAC,EAAE,KAAK,CAAC;YACxB,KAAK,CAAC,EAAE,MAAM,CAAC;YACf,IAAI,CAAC,EAAE,MAAM,CAAC;YACd,OAAO,CAAC,EAAE,MAAM,CAAC;SAClB,CAAC,CAAC;KACJ,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,UAAW,SAAQ,KAAK;IACvC,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAOhE;AAED,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/handlers/tool-configs/universal/core/error-enhancers/types.js

@@ -0,0 +1,42 @@
+/**
+ * Error Enhancer Strategy Pattern Types
+ * Issue #1001 - Refactoring crud-error-handlers.ts
+ */
+/**
+ * Extract error message from Error instances, axios-style errors, or test mocks
+ *
+ * Handles three cases:
+ * 1. Real Error instances: returns error.message
+ * 2. Error-like objects (axios/mocks): extracts message property
+ * 3. Primitive values: converts to string
+ *
+ * This helper was added to fix test compatibility issues where test mocks
+ * aren't true Error instances but have message properties. It provides a
+ * consistent way to extract error messages across production code and tests.
+ *
+ * @param error - Any error value (Error, axios error object, string, etc.)
+ * @returns Error message as string (never null/undefined)
+ *
+ * @example
+ * getErrorMessage(new Error("test")) // "test"
+ * getErrorMessage({ message: "axios error" }) // "axios error"
+ * getErrorMessage("string error") // "string error"
+ */
+export const getErrorMessage = (error) => {
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object' && 'message' in error) {
+        return String(error.message);
+    }
+    return String(error);
+};
+/**
+ * Type guard to check if error is an Axios error
+ */
+export function isAxiosError(error) {
+    return (error !== null &&
+        typeof error === 'object' &&
+        'response' in error &&
+        typeof error.response === 'object');
+}
+//# sourceMappingURL=types.js.map

package/dist/handlers/tool-configs/universal/core/error-enhancers/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/handlers/tool-configs/universal/core/error-enhancers/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoCH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAc,EAAU,EAAE;IACxD,IAAI,KAAK,YAAY,KAAK;QAAE,OAAO,KAAK,CAAC,OAAO,CAAC;IACjD,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,SAAS,IAAI,KAAK,EAAE,CAAC;QAC7D,OAAO,MAAM,CAAE,KAAiC,CAAC,OAAO,CAAC,CAAC;IAC5D,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC,CAAC;AAyBF;;GAEG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,OAAO,CACL,KAAK,KAAK,IAAI;QACd,OAAO,KAAK,KAAK,QAAQ;QACzB,UAAU,IAAI,KAAK;QACnB,OAAQ,KAAgC,CAAC,QAAQ,KAAK,QAAQ,CAC/D,CAAC;AACJ,CAAC"}

package/dist/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Uniqueness Error Enhancer
+ * Issue #1001 - Strategy Pattern for CRUD error handling
+ * Issue #990 - Enhanced uniqueness constraint violation handling
+ *
+ * Detects uniqueness/duplicate errors and attempts to find the
+ * conflicting record to provide actionable guidance.
+ */
+import type { ErrorEnhancer } from './types.js';
+/**
+ * Uniqueness Enhancer
+ * Detects duplicate/uniqueness constraint violations and finds the conflicting record
+ */
+export declare const uniquenessEnhancer: ErrorEnhancer;
+//# sourceMappingURL=uniqueness-enhancer.d.ts.map

package/dist/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueness-enhancer.d.ts","sourceRoot":"","sources":["../../../../../../src/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAoB,MAAM,YAAY,CAAC;AAqHlE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAiChC,CAAC"}

package/dist/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.js

@@ -0,0 +1,109 @@
+/**
+ * Uniqueness Error Enhancer
+ * Issue #1001 - Strategy Pattern for CRUD error handling
+ * Issue #990 - Enhanced uniqueness constraint violation handling
+ *
+ * Detects uniqueness/duplicate errors and attempts to find the
+ * conflicting record to provide actionable guidance.
+ */
+import { getSingularResourceType } from '../../../../../handlers/tool-configs/universal/shared-handlers.js';
+import { sanitizedLog } from '../../../../../handlers/tool-configs/universal/core/pii-sanitizer.js';
+import { createScopedLogger } from '../../../../../utils/logger.js';
+const logger = createScopedLogger('uniqueness-enhancer');
+/**
+ * Searches for conflicting record when uniqueness constraint violation occurs
+ */
+async function enhanceUniquenessErrorWithSearch(resourceType, recordData) {
+    const UNIQUE_FIELD_SEARCHERS = {
+        companies: {
+            fields: ['domains', 'domain'],
+            search: async (value) => {
+                const { searchCompaniesByDomain } = await import('../../../../../objects/companies/search.js');
+                return searchCompaniesByDomain(value);
+            },
+        },
+        people: {
+            fields: ['email_addresses', 'email', 'emails'],
+            search: async (value) => {
+                const { searchPeopleByEmail } = await import('../../../../../objects/people/search.js');
+                return searchPeopleByEmail(value);
+            },
+        },
+    };
+    const searcher = UNIQUE_FIELD_SEARCHERS[resourceType.toLowerCase()];
+    if (!searcher)
+        return null;
+    // Find which unique field has a value in recordData
+    for (const field of searcher.fields) {
+        let searchValue = recordData[field];
+        // Handle array format (e.g., domains: ["example.com"])
+        if (Array.isArray(searchValue) && searchValue.length > 0) {
+            searchValue = searchValue[0];
+        }
+        // Handle object format for emails (e.g., email_addresses: [{email_address: "..."}])
+        if (searchValue &&
+            typeof searchValue === 'object' &&
+            !Array.isArray(searchValue)) {
+            const obj = searchValue;
+            searchValue = obj.email_address || obj.email || obj.value;
+        }
+        if (searchValue && typeof searchValue === 'string') {
+            try {
+                const existing = await searcher.search(searchValue);
+                if (existing && existing.length > 0) {
+                    const recordId = existing[0]?.id?.record_id;
+                    if (recordId) {
+                        return formatUniquenessErrorMessage(resourceType, field, searchValue, recordId);
+                    }
+                }
+            }
+            catch (err) {
+                // Search failed, log and continue to fallback
+                sanitizedLog(logger, 'debug', 'Uniqueness search failed', {
+                    resourceType,
+                    field,
+                    error: String(err),
+                });
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Formats actionable error message for uniqueness constraint violations
+ */
+function formatUniquenessErrorMessage(resourceType, field, value, recordId) {
+    const singular = getSingularResourceType(resourceType);
+    return (`Uniqueness conflict on "${field}": value "${value}" already exists on ${singular} record.\n\n` +
+        `EXISTING RECORD ID: ${recordId}\n\n` +
+        `OPTIONS:\n` +
+        `1. Update existing: update-record(resource_type="${resourceType}", record_id="${recordId}", record_data={...})\n` +
+        `2. View existing: records_get_details(resource_type="${resourceType}", record_id="${recordId}")\n` +
+        `3. Use a different ${field} value`);
+}
+/**
+ * Uniqueness Enhancer
+ * Detects duplicate/uniqueness constraint violations and finds the conflicting record
+ */
+export const uniquenessEnhancer = {
+    name: 'uniqueness',
+    errorName: 'duplicate_error',
+    matches: (error, _context) => {
+        const msg = error instanceof Error ? error.message : String(error);
+        return (msg.includes('duplicate') ||
+            msg.toLowerCase().includes('uniqueness constraint'));
+    },
+    enhance: async (_error, context) => {
+        const { resourceType, recordData } = context;
+        if (!recordData)
+            return null;
+        // Try to find and identify the conflicting record
+        const enhancedMessage = await enhanceUniquenessErrorWithSearch(resourceType, recordData);
+        if (enhancedMessage) {
+            return enhancedMessage;
+        }
+        // Fallback message if we couldn't find the specific record
+        return 'A record with similar data already exists. Check unique fields like domains or email_addresses.';
+    },
+};
+//# sourceMappingURL=uniqueness-enhancer.js.map

package/dist/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueness-enhancer.js","sourceRoot":"","sources":["../../../../../../src/handlers/tool-configs/universal/core/error-enhancers/uniqueness-enhancer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,sDAAsD,CAAC;AAE/F,OAAO,EAAE,YAAY,EAAE,MAAM,yDAAyD,CAAC;AACvF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,MAAM,GAAG,kBAAkB,CAAC,qBAAqB,CAAC,CAAC;AAYzD;;GAEG;AACH,KAAK,UAAU,gCAAgC,CAC7C,YAAoB,EACpB,UAAmC;IAEnC,MAAM,sBAAsB,GAAwC;QAClE,SAAS,EAAE;YACT,MAAM,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;YAC7B,MAAM,EAAE,KAAK,EAAE,KAAa,EAAE,EAAE;gBAC9B,MAAM,EAAE,uBAAuB,EAAE,GAC/B,MAAM,MAAM,CAAC,+BAA+B,CAAC,CAAC;gBAChD,OAAO,uBAAuB,CAAC,KAAK,CAAC,CAAC;YACxC,CAAC;SACF;QACD,MAAM,EAAE;YACN,MAAM,EAAE,CAAC,iBAAiB,EAAE,OAAO,EAAE,QAAQ,CAAC;YAC9C,MAAM,EAAE,KAAK,EAAE,KAAa,EAAE,EAAE;gBAC9B,MAAM,EAAE,mBAAmB,EAAE,GAC3B,MAAM,MAAM,CAAC,4BAA4B,CAAC,CAAC;gBAC7C,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;YACpC,CAAC;SACF;KACF,CAAC;IAEF,MAAM,QAAQ,GAAG,sBAAsB,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IACpE,IAAI,CAAC,QAAQ;QAAE,OAAO,IAAI,CAAC;IAE3B,oDAAoD;IACpD,KAAK,MAAM,KAAK,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;QACpC,IAAI,WAAW,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;QAEpC,uDAAuD;QACvD,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzD,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC;QAC/B,CAAC;QAED,oFAAoF;QACpF,IACE,WAAW;YACX,OAAO,WAAW,KAAK,QAAQ;YAC/B,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,EAC3B,CAAC;YACD,MAAM,GAAG,GAAG,WAAsC,CAAC;YACnD,WAAW,GAAG,GAAG,CAAC,aAAa,IAAI,GAAG,CAAC,KAAK,IAAI,GAAG,CAAC,KAAK,CAAC;QAC5D,CAAC;QAED,IAAI,WAAW,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;YACnD,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;gBACpD,IAAI,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACpC,MAAM,QAAQ,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,CAAC;oBAC5C,IAAI,QAAQ,EAAE,CAAC;wBACb,OAAO,4BAA4B,CACjC,YAAY,EACZ,KAAK,EACL,WAAW,EACX,QAAQ,CACT,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,8CAA8C;gBAC9C,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,0BAA0B,EAAE;oBACxD,YAAY;oBACZ,KAAK;oBACL,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC;iBACnB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;GAEG;AACH,SAAS,4BAA4B,CACnC,YAAoB,EACpB,KAAa,EACb,KAAa,EACb,QAAgB;IAEhB,MAAM,QAAQ,GAAG,uBAAuB,CACtC,YAAqC,CACtC,CAAC;IAEF,OAAO,CACL,2BAA2B,KAAK,aAAa,KAAK,uBAAuB,QAAQ,cAAc;QAC/F,uBAAuB,QAAQ,MAAM;QACrC,YAAY;QACZ,oDAAoD,YAAY,iBAAiB,QAAQ,yBAAyB;QAClH,wDAAwD,YAAY,iBAAiB,QAAQ,MAAM;QACnG,sBAAsB,KAAK,QAAQ,CACpC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAkB;IAC/C,IAAI,EAAE,YAAY;IAClB,SAAS,EAAE,iBAAiB;IAE5B,OAAO,EAAE,CAAC,KAAc,EAAE,QAA0B,EAAW,EAAE;QAC/D,MAAM,GAAG,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QACnE,OAAO,CACL,GAAG,CAAC,QAAQ,CAAC,WAAW,CAAC;YACzB,GAAG,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,uBAAuB,CAAC,CACpD,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,KAAK,EACZ,MAAe,EACf,OAAyB,EACD,EAAE;QAC1B,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QAE7C,IAAI,CAAC,UAAU;YAAE,OAAO,IAAI,CAAC;QAE7B,kDAAkD;QAClD,MAAM,eAAe,GAAG,MAAM,gCAAgC,CAC5D,YAAY,EACZ,UAAU,CACX,CAAC;QAEF,IAAI,eAAe,EAAE,CAAC;YACpB,OAAO,eAAe,CAAC;QACzB,CAAC;QAED,2DAA2D;QAC3D,OAAO,iGAAiG,CAAC;IAC3G,CAAC;CACF,CAAC"}

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

@@ -1,35 +1,39 @@
 import { searchRecordsConfig } from './search-operations.js';
 import { getRecordDetailsConfig } from './record-details-operations.js';
 import { createRecordConfig, updateRecordConfig, deleteRecordConfig } from './crud-operations.js';
-import { getAttributesConfig, discoverAttributesConfig } from './metadata-operations.js';
+import { getAttributesConfig, discoverAttributesConfig, getAttributeOptionsConfig } from './metadata-operations.js';
 import { getDetailedInfoConfig } from './detailed-info-operations.js';
 import { createNoteConfig, listNotesConfig } from './notes-operations.js';
 export declare const coreOperationsToolConfigs: {
-    'create-note': import("../types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown>>;
-    'list-notes': import("../types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown>[]>;
-    records_search: import("../types.js").UniversalToolConfig<import("../types.js").UniversalSearchParams, import("../../../../types/attio.js").AttioRecord[]>;
-    records_get_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, {
+    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").UniversalRecordResult[]>;
+    get_record_details: import("../types.js").UniversalToolConfig<import("../types.js").UniversalRecordDetailsParams, import("../../../../types/attio.js").UniversalRecordResult>;
+    create_record: import("../types.js").UniversalToolConfig<import("../types.js").UniversalCreateParams, import("./utils.js").UniversalRecord>;
+    update_record: import("../types.js").UniversalToolConfig<import("../types.js").UniversalUpdateParams, import("./utils.js").UniversalRecord>;
+    delete_record: import("../types.js").UniversalToolConfig<import("../types.js").UniversalDeleteParams, {
         success: boolean;
         record_id: string;
     }>;
-    records_get_attributes: import("../types.js").UniversalToolConfig<import("../types.js").UniversalAttributesParams, Record<string, unknown> | {
+    get_record_attributes: import("../types.js").UniversalToolConfig<import("../types.js").UniversalAttributesParams, Record<string, unknown> | {
         error: string;
         success: boolean;
     }>;
-    records_discover_attributes: import("../types.js").UniversalToolConfig<{
+    discover_record_attributes: import("../types.js").UniversalToolConfig<{
         resource_type: import("../types.js").UniversalResourceType;
         categories?: string[];
     }, Record<string, unknown> | {
         error: string;
         success: boolean;
     }>;
-    records_get_info: import("../types.js").UniversalToolConfig<import("../types.js").UniversalDetailedInfoParams, Record<string, unknown>>;
+    get_record_attribute_options: import("../types.js").UniversalToolConfig<import("../types.js").UniversalGetAttributeOptionsParams, import("../../../../services/metadata/AttributeOptionsService.js").AttributeOptionsResult | {
+        error: string;
+        success: boolean;
+    }>;
+    get_record_info: import("../types.js").UniversalToolConfig<import("../types.js").UniversalDetailedInfoParams, Record<string, unknown>>;
 };
 export declare const coreOperationsToolDefinitions: {
-    records_search: {
+    search_records: {
         name: string;
         description: string;
         inputSchema: {
@@ -158,7 +162,7 @@ export declare const coreOperationsToolDefinitions: {
             idempotentHint: boolean;
         };
     };
-    records_get_details: {
+    get_record_details: {
         name: string;
         description: string;
         inputSchema: {
@@ -193,7 +197,7 @@ export declare const coreOperationsToolDefinitions: {
             idempotentHint: boolean;
         };
     };
-    'create-record': {
+    create_record: {
         name: string;
         description: string;
         inputSchema: {
@@ -232,7 +236,7 @@ export declare const coreOperationsToolDefinitions: {
             destructiveHint: boolean;
         };
     };
-    'update-record': {
+    update_record: {
         name: string;
         description: string;
         inputSchema: {
@@ -273,7 +277,7 @@ export declare const coreOperationsToolDefinitions: {
             destructiveHint: boolean;
         };
     };
-    'delete-record': {
+    delete_record: {
         name: string;
         description: string;
         inputSchema: {
@@ -300,7 +304,7 @@ export declare const coreOperationsToolDefinitions: {
             destructiveHint: boolean;
         };
     };
-    records_get_attributes: {
+    get_record_attributes: {
         name: string;
         description: string;
         inputSchema: {
@@ -341,7 +345,7 @@ export declare const coreOperationsToolDefinitions: {
             idempotentHint: boolean;
         };
     };
-    records_discover_attributes: {
+    discover_record_attributes: {
         name: string;
         description: string;
         inputSchema: {
@@ -371,7 +375,44 @@ export declare const coreOperationsToolDefinitions: {
             idempotentHint: boolean;
         };
     };
-    records_get_info: {
+    get_record_attribute_options: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                resource_type: {
+                    type: "string";
+                    description: string;
+                };
+                attribute: {
+                    type: "string";
+                    description: string;
+                };
+                show_archived: {
+                    type: "boolean";
+                    default: boolean;
+                    description: string;
+                };
+            };
+            required: ("attribute" | "resource_type")[];
+            additionalProperties: boolean;
+            examples: ({
+                resource_type: string;
+                attribute: string;
+                show_archived?: undefined;
+            } | {
+                resource_type: string;
+                attribute: string;
+                show_archived: boolean;
+            })[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    get_record_info: {
         name: string;
         description: string;
         inputSchema: {
@@ -399,7 +440,7 @@ export declare const coreOperationsToolDefinitions: {
             idempotentHint: boolean;
         };
     };
-    'create-note': {
+    create_note: {
         name: string;
         description: string;
         inputSchema: {
@@ -437,7 +478,7 @@ export declare const coreOperationsToolDefinitions: {
             destructiveHint: boolean;
         };
     };
-    'list-notes': {
+    list_notes: {
         name: string;
         description: string;
         inputSchema: {
@@ -478,5 +519,5 @@ export declare const coreOperationsToolDefinitions: {
         };
     };
 };
-export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
+export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getAttributeOptionsConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAEpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EAEvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAInB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EAGzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,EAEtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,gBAAgB,EAChB,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;CAWrC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWzC,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,GAChB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAEpB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EAEvB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAInB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EAI1B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,EAEtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,gBAAgB,EAChB,eAAe,EAGhB,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYrC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYzC,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,qBAAqB,EACrB,gBAAgB,EAChB,eAAe,GAChB,CAAC"}

package/dist/handlers/tool-configs/universal/core/index.js

@@ -1,32 +1,34 @@
 import { searchRecordsConfig, searchRecordsDefinition, } from './search-operations.js';
 import { getRecordDetailsConfig, getRecordDetailsDefinition, } from './record-details-operations.js';
 import { createRecordConfig, updateRecordConfig, deleteRecordConfig, createRecordDefinition, updateRecordDefinition, deleteRecordDefinition, } from './crud-operations.js';
-import { getAttributesConfig, discoverAttributesConfig, getAttributesDefinition, discoverAttributesDefinition, } from './metadata-operations.js';
+import { getAttributesConfig, discoverAttributesConfig, getAttributeOptionsConfig, getAttributesDefinition, discoverAttributesDefinition, getAttributeOptionsDefinition, } from './metadata-operations.js';
 import { getDetailedInfoConfig, getDetailedInfoDefinition, } from './detailed-info-operations.js';
 import { createNoteConfig, listNotesConfig, createNoteDefinition, listNotesDefinition, } from './notes-operations.js';
 export const coreOperationsToolConfigs = {
-    'create-note': createNoteConfig,
-    'list-notes': listNotesConfig,
-    records_search: searchRecordsConfig,
-    records_get_details: getRecordDetailsConfig,
-    'create-record': createRecordConfig,
-    'update-record': updateRecordConfig,
-    'delete-record': deleteRecordConfig,
-    records_get_attributes: getAttributesConfig,
-    records_discover_attributes: discoverAttributesConfig,
-    records_get_info: getDetailedInfoConfig,
+    create_note: createNoteConfig,
+    list_notes: listNotesConfig,
+    search_records: searchRecordsConfig,
+    get_record_details: getRecordDetailsConfig,
+    create_record: createRecordConfig,
+    update_record: updateRecordConfig,
+    delete_record: deleteRecordConfig,
+    get_record_attributes: getAttributesConfig,
+    discover_record_attributes: discoverAttributesConfig,
+    get_record_attribute_options: getAttributeOptionsConfig,
+    get_record_info: getDetailedInfoConfig,
 };
 export const coreOperationsToolDefinitions = {
-    records_search: searchRecordsDefinition,
-    records_get_details: getRecordDetailsDefinition,
-    'create-record': createRecordDefinition,
-    'update-record': updateRecordDefinition,
-    'delete-record': deleteRecordDefinition,
-    records_get_attributes: getAttributesDefinition,
-    records_discover_attributes: discoverAttributesDefinition,
-    records_get_info: getDetailedInfoDefinition,
-    'create-note': createNoteDefinition,
-    'list-notes': listNotesDefinition,
+    search_records: searchRecordsDefinition,
+    get_record_details: getRecordDetailsDefinition,
+    create_record: createRecordDefinition,
+    update_record: updateRecordDefinition,
+    delete_record: deleteRecordDefinition,
+    get_record_attributes: getAttributesDefinition,
+    discover_record_attributes: discoverAttributesDefinition,
+    get_record_attribute_options: getAttributeOptionsDefinition,
+    get_record_info: getDetailedInfoDefinition,
+    create_note: createNoteDefinition,
+    list_notes: listNotesDefinition,
 };
-export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
+export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getAttributeOptionsConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
 //# sourceMappingURL=index.js.map