attio-mcp 0.1.2 → 1.1.0

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

@@ -0,0 +1,470 @@
+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 { 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, {
+        success: boolean;
+        record_id: string;
+    }>;
+    records_get_attributes: import("../types.js").UniversalToolConfig<import("../types.js").UniversalAttributesParams, Record<string, unknown> | {
+        error: string;
+        success: boolean;
+    }>;
+    records_discover_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>>;
+};
+export declare const coreOperationsToolDefinitions: {
+    records_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;
+                };
+                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;
+            examples: {
+                resource_type: string;
+                query: string;
+                limit: number;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    records_get_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;
+            examples: {
+                resource_type: string;
+                record_id: string;
+                fields: string[];
+            }[];
+        };
+        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;
+            examples: {
+                resource_type: string;
+                record_data: {
+                    name: string;
+                    email_addresses: {
+                        email_address: string;
+                    }[];
+                };
+                return_details: 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;
+            examples: {
+                resource_type: string;
+                record_id: string;
+                record_data: {
+                    status: string;
+                };
+                return_details: 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;
+            examples: {
+                resource_type: string;
+                record_id: string;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+    records_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;
+            examples: {
+                resource_type: string;
+                categories: string[];
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    records_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;
+            examples: {
+                resource_type: string;
+                categories: string[];
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    records_get_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;
+            examples: {
+                resource_type: string;
+                record_id: string;
+            }[];
+        };
+        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;
+                };
+                format: {
+                    type: "string";
+                    enum: string[];
+                    description: string;
+                    default: string;
+                };
+            };
+            required: ("title" | "content" | "record_id" | "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;
+        };
+    };
+};
+export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,32 @@
+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 { 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,
+};
+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,
+};
+export { searchRecordsConfig, getRecordDetailsConfig, createRecordConfig, updateRecordConfig, deleteRecordConfig, getAttributesConfig, discoverAttributesConfig, getDetailedInfoConfig, createNoteConfig, listNotesConfig, };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACL,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,4BAA4B,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,qBAAqB,EACrB,yBAAyB,GAC1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,aAAa,EAAE,gBAAgB;IAC/B,YAAY,EAAE,eAAe;IAC7B,cAAc,EAAE,mBAAmB;IACnC,mBAAmB,EAAE,sBAAsB;IAC3C,eAAe,EAAE,kBAAkB;IACnC,eAAe,EAAE,kBAAkB;IACnC,eAAe,EAAE,kBAAkB;IACnC,sBAAsB,EAAE,mBAAmB;IAC3C,2BAA2B,EAAE,wBAAwB;IACrD,gBAAgB,EAAE,qBAAqB;CACxC,CAAC;AAEF,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,cAAc,EAAE,uBAAuB;IACvC,mBAAmB,EAAE,0BAA0B;IAC/C,eAAe,EAAE,sBAAsB;IACvC,eAAe,EAAE,sBAAsB;IACvC,eAAe,EAAE,sBAAsB;IACvC,sBAAsB,EAAE,uBAAuB;IAC/C,2BAA2B,EAAE,4BAA4B;IACzD,gBAAgB,EAAE,yBAAyB;IAC3C,aAAa,EAAE,oBAAoB;IACnC,YAAY,EAAE,mBAAmB;CAClC,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"}

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

@@ -0,0 +1,86 @@
+import { UniversalToolConfig, UniversalAttributesParams, UniversalResourceType } from '../types.js';
+export declare const getAttributesConfig: UniversalToolConfig<UniversalAttributesParams, Record<string, unknown> | {
+    error: string;
+    success: boolean;
+}>;
+export declare const discoverAttributesConfig: UniversalToolConfig<{
+    resource_type: UniversalResourceType;
+    categories?: string[];
+}, Record<string, unknown> | {
+    error: string;
+    success: boolean;
+}>;
+export declare const getAttributesDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            resource_type: {
+                type: "string";
+                enum: 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;
+        examples: {
+            resource_type: string;
+            categories: string[];
+        }[];
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+};
+export declare const discoverAttributesDefinition: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            resource_type: {
+                type: "string";
+                enum: UniversalResourceType[];
+                description: string;
+            };
+            categories: {
+                type: "array";
+                items: {
+                    type: "string";
+                };
+                description: string;
+            };
+        };
+        required: "resource_type"[];
+        additionalProperties: boolean;
+        examples: {
+            resource_type: string;
+            categories: string[];
+        }[];
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+    };
+};
+//# sourceMappingURL=metadata-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-operations.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/core/metadata-operations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,aAAa,CAAC;AAarB,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CACnD,yBAAyB,EACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAwF9D,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CACxD;IAAE,aAAa,EAAE,qBAAqB,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,EAC/D,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CA8H9D,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcnC,CAAC;AAEF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAexC,CAAC"}