@iflow-mcp/attio-mcp 1.3.6

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

@@ -0,0 +1,317 @@
+/**
+ * Advanced operations aggregator (barrel)
+ * Exposes tool configs and definitions for universal advanced operations
+ */
+import { advancedSearchConfig } from './advanced-search.js';
+import { searchByRelationshipConfig } from './relationship-search.js';
+import { searchByContentConfig } from './content-search.js';
+import { searchByTimeframeConfig } from './timeframe-search.js';
+import { batchOperationsConfig } from './batch-operations.js';
+export declare const advancedOperationsToolConfigs: {
+    search_records_advanced: import("../types.js").UniversalToolConfig<import("../types.js").AdvancedSearchParams, import("../../../../types/attio.js").AttioRecord[]>;
+    search_records_by_relationship: import("../types.js").UniversalToolConfig<import("../types.js").RelationshipSearchParams, import("../../../../types/attio.js").AttioRecord[]>;
+    search_records_by_content: import("../types.js").UniversalToolConfig<import("../types.js").ContentSearchParams, import("../../../../types/attio.js").AttioRecord[]>;
+    search_records_by_timeframe: import("../types.js").UniversalToolConfig<import("../types.js").TimeframeSearchParams, import("../../../../types/attio.js").AttioRecord[]>;
+    batch_records: import("../types.js").UniversalToolConfig<Record<string, unknown>, Record<string, unknown> | Record<string, unknown>[]>;
+};
+export declare const advancedOperationsToolDefinitions: {
+    search_records_advanced: {
+        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";
+                    description: string;
+                };
+                query: {
+                    type: "string";
+                    description: string;
+                };
+                filters: {
+                    type: "object";
+                    description: string;
+                    additionalProperties: boolean;
+                };
+                sort_by: {
+                    type: "string";
+                    description: string;
+                };
+                sort_order: {
+                    type: "string";
+                    enum: string[];
+                    default: string;
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+            examples: {
+                resource_type: string;
+                filters: {
+                    filters: {
+                        attribute: {
+                            slug: string;
+                        };
+                        condition: string;
+                        value: string;
+                    }[];
+                };
+                limit: number;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    search_records_by_relationship: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                relationship_type: {
+                    type: "string";
+                    enum: import("../types.js").RelationshipType[];
+                    description: string;
+                };
+                source_id: {
+                    type: "string";
+                    description: string;
+                };
+                target_resource_type: {
+                    type: "string";
+                    enum: import("../types.js").UniversalResourceType[];
+                    description: string;
+                };
+                listId: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("source_id" | "relationship_type")[];
+            additionalProperties: boolean;
+            examples: {
+                relationship_type: import("../types.js").RelationshipType;
+                source_id: string;
+                target_resource_type: string;
+                limit: number;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    search_records_by_content: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    description: string;
+                };
+                content_type: {
+                    type: "string";
+                    enum: import("../types.js").ContentSearchType[];
+                    description: string;
+                };
+                search_query: {
+                    type: "string";
+                    description: string;
+                };
+            };
+            required: ("resource_type" | "content_type" | "search_query")[];
+            additionalProperties: boolean;
+            examples: {
+                resource_type: string;
+                content_type: import("../types.js").ContentSearchType;
+                search_query: string;
+                limit: number;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    search_records_by_timeframe: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    description: string;
+                };
+                timeframe_type: {
+                    type: "string";
+                    enum: import("../types.js").TimeframeType[];
+                    description: string;
+                };
+                start_date: {
+                    type: "string";
+                    format: string;
+                    description: string;
+                };
+                end_date: {
+                    type: "string";
+                    format: string;
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+            examples: {
+                resource_type: string;
+                timeframe_type: import("../types.js").TimeframeType;
+                start_date: string;
+                end_date: string;
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            idempotentHint: boolean;
+        };
+    };
+    batch_records: {
+        name: string;
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                limit: {
+                    type: "number";
+                    minimum: number;
+                    maximum: number;
+                    default: number;
+                    description: string;
+                };
+                offset: {
+                    type: "number";
+                    minimum: number;
+                    default: number;
+                    description: string;
+                };
+                resource_type: {
+                    type: "string";
+                    description: string;
+                };
+                operations: {
+                    type: "array";
+                    items: {
+                        type: "object";
+                        properties: {
+                            operation: {
+                                type: "string";
+                                enum: string[];
+                                description: string;
+                            };
+                            record_data: {
+                                type: "object";
+                                additionalProperties: boolean;
+                                description: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    description: string;
+                };
+                operation_type: {
+                    type: "string";
+                    enum: import("../types.js").BatchOperationType[];
+                    description: string;
+                };
+                records: {
+                    type: "array";
+                    items: {
+                        type: "object";
+                        additionalProperties: boolean;
+                    };
+                    description: string;
+                };
+                record_ids: {
+                    type: "array";
+                    items: {
+                        type: "string";
+                    };
+                    description: string;
+                };
+            };
+            required: "resource_type"[];
+            additionalProperties: boolean;
+            examples: {
+                resource_type: string;
+                operation_type: import("../types.js").BatchOperationType;
+                records: {
+                    name: string;
+                    domain: string;
+                }[];
+            }[];
+        };
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+        };
+    };
+};
+export { advancedSearchConfig, searchByRelationshipConfig, searchByContentConfig, searchByTimeframeConfig, batchOperationsConfig, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/operations/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAW9D,eAAO,MAAM,6BAA6B;;;;;;CAMzC,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoF7C,CAAC;AAEF,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,CAAC"}

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

@@ -0,0 +1,93 @@
+/**
+ * Advanced operations aggregator (barrel)
+ * Exposes tool configs and definitions for universal advanced operations
+ */
+import { advancedSearchConfig } from './advanced-search.js';
+import { searchByRelationshipConfig } from './relationship-search.js';
+import { searchByContentConfig } from './content-search.js';
+import { searchByTimeframeConfig } from './timeframe-search.js';
+import { batchOperationsConfig } from './batch-operations.js';
+import { formatToolDescription } from '../../../../handlers/tools/standards/index.js';
+import { advancedSearchSchema, searchByRelationshipSchema, searchByContentSchema, searchByTimeframeSchema, batchOperationsSchema, } from '../schemas.js';
+export const advancedOperationsToolConfigs = {
+    search_records_advanced: advancedSearchConfig,
+    search_records_by_relationship: searchByRelationshipConfig,
+    search_records_by_content: searchByContentConfig,
+    search_records_by_timeframe: searchByTimeframeConfig,
+    batch_records: batchOperationsConfig,
+};
+export const advancedOperationsToolDefinitions = {
+    search_records_advanced: {
+        name: 'search_records_advanced',
+        description: formatToolDescription({
+            capability: 'Search companies, people, deals, or tasks with complex nested filters (e.g., find deals by owner+stage, companies by industry+location).',
+            boundaries: 'mutate records; use records.update or records.delete.',
+            constraints: 'Supports filter groups, scoring, pagination, and up to 100 items. Requires resource_type parameter.',
+            recoveryHint: 'If filters fail, fetch valid attributes via records.discover_attributes.',
+        }),
+        inputSchema: advancedSearchSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
+    },
+    search_records_by_relationship: {
+        name: 'search_records_by_relationship',
+        description: formatToolDescription({
+            capability: 'Search records using relationship anchors (list, company, people).',
+            boundaries: 'modify memberships; use list tools for writes.',
+            constraints: 'Requires resource_type and related resource identifier.',
+            recoveryHint: 'Use records.search to resolve IDs before calling.',
+        }),
+        inputSchema: searchByRelationshipSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
+    },
+    search_records_by_content: {
+        name: 'search_records_by_content',
+        description: formatToolDescription({
+            capability: 'Search record content (notes, activity, communications).',
+            boundaries: 'modify note content or attachments.',
+            constraints: 'Requires resource_type and content_query; optional fields array.',
+            recoveryHint: 'Narrow scope with fields or switch to records.search_advanced.',
+        }),
+        inputSchema: searchByContentSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
+    },
+    search_records_by_timeframe: {
+        name: 'search_records_by_timeframe',
+        description: formatToolDescription({
+            capability: 'Filter records by creation, update, or interaction timeframes.',
+            boundaries: 'modify lifecycle state or scheduling follow-ups.',
+            constraints: 'Requires resource_type; provide timeframe or explicit date boundaries.',
+            recoveryHint: 'Call records.search if timeframe filters are too restrictive.',
+        }),
+        inputSchema: searchByTimeframeSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+        },
+    },
+    batch_records: {
+        name: 'batch_records',
+        description: formatToolDescription({
+            capability: 'Execute batched record operations (create/update/delete/get/search).',
+            boundaries: 'ignore approval guardrails; hosts may require confirmation.',
+            requiresApproval: true,
+            constraints: 'operation_type must be specified; enforce per-operation limits.',
+            recoveryHint: 'Run records.search first to stage IDs or payloads for batching.',
+        }),
+        inputSchema: batchOperationsSchema,
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+        },
+    },
+};
+export { advancedSearchConfig, searchByRelationshipConfig, searchByContentConfig, searchByTimeframeConfig, batchOperationsConfig, };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/operations/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAE5E,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,eAAe,CAAC;AAEvB,MAAM,CAAC,MAAM,6BAA6B,GAAG;IAC3C,uBAAuB,EAAE,oBAAoB;IAC7C,8BAA8B,EAAE,0BAA0B;IAC1D,yBAAyB,EAAE,qBAAqB;IAChD,2BAA2B,EAAE,uBAAuB;IACpD,aAAa,EAAE,qBAAqB;CACrC,CAAC;AAEF,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,uBAAuB,EAAE;QACvB,IAAI,EAAE,yBAAyB;QAC/B,WAAW,EAAE,qBAAqB,CAAC;YACjC,UAAU,EACR,0IAA0I;YAC5I,UAAU,EAAE,uDAAuD;YACnE,WAAW,EACT,qGAAqG;YACvG,YAAY,EACV,0EAA0E;SAC7E,CAAC;QACF,WAAW,EAAE,oBAAoB;QACjC,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,cAAc,EAAE,IAAI;SACrB;KACF;IACD,8BAA8B,EAAE;QAC9B,IAAI,EAAE,gCAAgC;QACtC,WAAW,EAAE,qBAAqB,CAAC;YACjC,UAAU,EACR,oEAAoE;YACtE,UAAU,EAAE,gDAAgD;YAC5D,WAAW,EAAE,yDAAyD;YACtE,YAAY,EAAE,mDAAmD;SAClE,CAAC;QACF,WAAW,EAAE,0BAA0B;QACvC,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,cAAc,EAAE,IAAI;SACrB;KACF;IACD,yBAAyB,EAAE;QACzB,IAAI,EAAE,2BAA2B;QACjC,WAAW,EAAE,qBAAqB,CAAC;YACjC,UAAU,EAAE,0DAA0D;YACtE,UAAU,EAAE,qCAAqC;YACjD,WAAW,EACT,kEAAkE;YACpE,YAAY,EACV,gEAAgE;SACnE,CAAC;QACF,WAAW,EAAE,qBAAqB;QAClC,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,cAAc,EAAE,IAAI;SACrB;KACF;IACD,2BAA2B,EAAE;QAC3B,IAAI,EAAE,6BAA6B;QACnC,WAAW,EAAE,qBAAqB,CAAC;YACjC,UAAU,EACR,gEAAgE;YAClE,UAAU,EAAE,kDAAkD;YAC9D,WAAW,EACT,wEAAwE;YAC1E,YAAY,EACV,+DAA+D;SAClE,CAAC;QACF,WAAW,EAAE,uBAAuB;QACpC,WAAW,EAAE;YACX,YAAY,EAAE,IAAI;YAClB,cAAc,EAAE,IAAI;SACrB;KACF;IACD,aAAa,EAAE;QACb,IAAI,EAAE,eAAe;QACrB,WAAW,EAAE,qBAAqB,CAAC;YACjC,UAAU,EACR,sEAAsE;YACxE,UAAU,EAAE,6DAA6D;YACzE,gBAAgB,EAAE,IAAI;YACtB,WAAW,EACT,iEAAiE;YACnE,YAAY,EACV,iEAAiE;SACpE,CAAC;QACF,WAAW,EAAE,qBAAqB;QAClC,WAAW,EAAE;YACX,YAAY,EAAE,KAAK;YACnB,eAAe,EAAE,IAAI;SACtB;KACF;CACF,CAAC;AAEF,OAAO,EACL,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { JsonObject } from '../../../../types/attio.js';
+import { UniversalResourceType } from '../types.js';
+type LegacyBatchParams = {
+    resourceType: UniversalResourceType;
+    params: JsonObject;
+};
+export declare function executeLegacyBatch({ resourceType, params, }: LegacyBatchParams): Promise<JsonObject | JsonObject[]>;
+export {};
+//# sourceMappingURL=legacy-handlers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-handlers.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/tool-configs/universal/operations/legacy-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,qBAAqB,EAAsB,MAAM,aAAa,CAAC;AA0BxE,KAAK,iBAAiB,GAAG;IACvB,YAAY,EAAE,qBAAqB,CAAC;IACpC,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAWF,wBAAsB,kBAAkB,CAAC,EACvC,YAAY,EACZ,MAAM,GACP,EAAE,iBAAiB,GAAG,OAAO,CAAC,UAAU,GAAG,UAAU,EAAE,CAAC,CAqBxD"}