@todoist/mcp 0.0.1 → 15.0.0

package/dist/tools/fetch.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+type FetchResult = {
+    id: string;
+    title: string;
+    text: string;
+    url: string;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
+ *
+ * This tool follows the OpenAI MCP fetch tool specification:
+ * @see https://platform.openai.com/docs/mcp#fetch-tool
+ */
+declare const fetch: {
+    name: "fetch";
+    description: string;
+    parameters: {
+        id: z.ZodString;
+    };
+    outputSchema: {
+        id: z.ZodString;
+        title: z.ZodString;
+        text: z.ZodString;
+        url: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        id: string;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: FetchResult;
+    }>;
+};
+export { fetch };
+//# sourceMappingURL=fetch.d.ts.map

package/dist/tools/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/tools/fetch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAcvB,KAAK,WAAW,GAAG;IACf,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC,CAAA;AAaD;;;;;GAKG;AACH,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;CAsGoD,CAAA;AAE/D,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/tools/find-activity.d.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+declare const findActivity: {
+    name: "find-activity";
+    description: string;
+    parameters: {
+        objectType: z.ZodOptional<z.ZodEnum<{
+            task: "task";
+            comment: "comment";
+            project: "project";
+        }>>;
+        objectId: z.ZodOptional<z.ZodString>;
+        eventType: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            added: "added";
+            updated: "updated";
+            deleted: "deleted";
+            uncompleted: "uncompleted";
+            archived: "archived";
+            unarchived: "unarchived";
+            shared: "shared";
+            left: "left";
+            moved: "moved";
+        }>>;
+        projectId: z.ZodOptional<z.ZodString>;
+        taskId: z.ZodOptional<z.ZodString>;
+        initiatorId: z.ZodOptional<z.ZodString>;
+        dateFrom: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>, z.ZodOptional<z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>>>;
+        dateTo: z.ZodPipe<z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>, z.ZodOptional<z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>>>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        events: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            objectType: z.ZodString;
+            objectId: z.ZodString;
+            eventType: z.ZodString;
+            eventDate: z.ZodString;
+            parentProjectId: z.ZodOptional<z.ZodString>;
+            parentItemId: z.ZodOptional<z.ZodString>;
+            initiatorId: z.ZodOptional<z.ZodString>;
+            extraData: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        limit: number;
+        objectType?: "task" | "comment" | "project" | undefined;
+        objectId?: string | undefined;
+        eventType?: "completed" | "added" | "updated" | "deleted" | "uncompleted" | "archived" | "unarchived" | "shared" | "left" | "moved" | undefined;
+        projectId?: string | undefined;
+        taskId?: string | undefined;
+        initiatorId?: string | undefined;
+        dateFrom?: string | undefined;
+        dateTo?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            events: {
+                id: string | undefined;
+                objectType: string;
+                objectId: string;
+                eventType: string;
+                eventDate: string;
+                parentProjectId: string | undefined;
+                parentItemId: string | undefined;
+                initiatorId: string | undefined;
+                extraData: Record<string, any> | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                limit: number;
+                objectType?: "task" | "comment" | "project" | undefined;
+                objectId?: string | undefined;
+                eventType?: "completed" | "added" | "updated" | "deleted" | "uncompleted" | "archived" | "unarchived" | "shared" | "left" | "moved" | undefined;
+                projectId?: string | undefined;
+                taskId?: string | undefined;
+                initiatorId?: string | undefined;
+                dateFrom?: string | undefined;
+                dateTo?: string | undefined;
+                cursor?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findActivity };
+//# sourceMappingURL=find-activity.d.ts.map

package/dist/tools/find-activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-activity.d.ts","sourceRoot":"","sources":["../../src/tools/find-activity.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmEvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqE6C,CAAA;AAgK/D,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-comments.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+declare const findComments: {
+    name: "find-comments";
+    description: string;
+    parameters: {
+        taskId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        commentId: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    };
+    outputSchema: {
+        comments: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            taskId: z.ZodOptional<z.ZodString>;
+            projectId: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+            postedAt: z.ZodString;
+            postedUid: z.ZodOptional<z.ZodString>;
+            notifiedUserIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fileAttachment: z.ZodOptional<z.ZodObject<{
+                resourceType: z.ZodString;
+                fileName: z.ZodOptional<z.ZodString>;
+                fileSize: z.ZodOptional<z.ZodNumber>;
+                fileType: z.ZodOptional<z.ZodString>;
+                fileUrl: z.ZodOptional<z.ZodString>;
+                fileDuration: z.ZodOptional<z.ZodNumber>;
+                uploadState: z.ZodOptional<z.ZodEnum<{
+                    pending: "pending";
+                    completed: "completed";
+                }>>;
+                url: z.ZodOptional<z.ZodString>;
+                title: z.ZodOptional<z.ZodString>;
+                image: z.ZodOptional<z.ZodString>;
+                imageWidth: z.ZodOptional<z.ZodNumber>;
+                imageHeight: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        searchType: z.ZodString;
+        searchId: z.ZodString;
+        hasMore: z.ZodBoolean;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        taskId?: string | undefined;
+        projectId?: string | undefined;
+        commentId?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            comments: {
+                id: string;
+                taskId: string | undefined;
+                projectId: string | undefined;
+                content: string;
+                postedAt: string;
+                postedUid: string;
+                notifiedUserIds: string[] | undefined;
+                fileAttachment: {
+                    resourceType: string;
+                    fileName: string | undefined;
+                    fileSize: number | undefined;
+                    fileType: string | undefined;
+                    fileUrl: string | undefined;
+                    fileDuration: number | undefined;
+                    uploadState: "pending" | "completed" | undefined;
+                    url: string | undefined;
+                    title: string | undefined;
+                    image: string | undefined;
+                    imageWidth: number | undefined;
+                    imageHeight: number | undefined;
+                } | undefined;
+            }[];
+            searchType: string;
+            searchId: string;
+            hasMore: boolean;
+            nextCursor: string | undefined;
+            totalCount: number;
+        };
+    }>;
+};
+export { findComments };
+//# sourceMappingURL=find-comments.d.ts.map

package/dist/tools/find-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwCvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkF6C,CAAA;AAmD/D,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-completed-tasks.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+declare const findCompletedTasks: {
+    name: "find-completed-tasks";
+    description: string;
+    parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<{
+            and: "and";
+            or: "or";
+        }>>;
+        getBy: z.ZodDefault<z.ZodEnum<{
+            due: "due";
+            completion: "completion";
+        }>>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        sectionId: z.ZodOptional<z.ZodString>;
+        parentId: z.ZodOptional<z.ZodString>;
+        responsibleUser: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            description: z.ZodString;
+            dueDate: z.ZodOptional<z.ZodString>;
+            recurring: z.ZodUnion<readonly [z.ZodBoolean, z.ZodString]>;
+            deadlineDate: z.ZodOptional<z.ZodString>;
+            priority: z.ZodEnum<{
+                p1: "p1";
+                p2: "p2";
+                p3: "p3";
+                p4: "p4";
+            }>;
+            projectId: z.ZodString;
+            sectionId: z.ZodOptional<z.ZodString>;
+            parentId: z.ZodOptional<z.ZodString>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            duration: z.ZodOptional<z.ZodString>;
+            responsibleUid: z.ZodOptional<z.ZodString>;
+            isUncompletable: z.ZodOptional<z.ZodBoolean>;
+            assignedByUid: z.ZodOptional<z.ZodString>;
+            isDeleted: z.ZodOptional<z.ZodBoolean>;
+            checked: z.ZodBoolean;
+            completedAt: z.ZodOptional<z.ZodString>;
+            addedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        getBy: "due" | "completion";
+        limit: number;
+        labels?: string[] | undefined;
+        labelsOperator?: "and" | "or" | undefined;
+        since?: string | undefined;
+        until?: string | undefined;
+        workspaceId?: string | undefined;
+        projectId?: string | undefined;
+        sectionId?: string | undefined;
+        parentId?: string | undefined;
+        responsibleUser?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            tasks: {
+                id: string;
+                content: string;
+                description: string;
+                dueDate: string | undefined;
+                recurring: string | boolean;
+                deadlineDate: string | undefined;
+                priority: "p1" | "p2" | "p3" | "p4";
+                projectId: string;
+                sectionId: string | undefined;
+                parentId: string | undefined;
+                labels: string[];
+                duration: string | undefined;
+                responsibleUid: string | undefined;
+                assignedByUid: string | undefined;
+                isDeleted: true | undefined;
+                checked: boolean;
+                completedAt: string | undefined;
+                addedAt: string | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            appliedFilters: {
+                since: string;
+                until: string;
+                getBy: "due" | "completion";
+                limit: number;
+                labels?: string[] | undefined;
+                labelsOperator?: "and" | "or" | undefined;
+                workspaceId?: string | undefined;
+                projectId?: string | undefined;
+                sectionId?: string | undefined;
+                parentId?: string | undefined;
+                responsibleUser?: string | undefined;
+                cursor?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findCompletedTasks };
+//# sourceMappingURL=find-completed-tasks.d.ts.map

package/dist/tools/find-completed-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-completed-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-completed-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA+GvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+GuC,CAAA;AAoE/D,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/tools/find-filters.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+declare const FilterOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    query: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        berry_red: "berry_red";
+        red: "red";
+        orange: "orange";
+        yellow: "yellow";
+        olive_green: "olive_green";
+        lime_green: "lime_green";
+        green: "green";
+        mint_green: "mint_green";
+        teal: "teal";
+        sky_blue: "sky_blue";
+        light_blue: "light_blue";
+        blue: "blue";
+        grape: "grape";
+        violet: "violet";
+        lavender: "lavender";
+        magenta: "magenta";
+        salmon: "salmon";
+        charcoal: "charcoal";
+        grey: "grey";
+        taupe: "taupe";
+    }>>>;
+    isFavorite: z.ZodBoolean;
+    itemOrder: z.ZodNumber;
+}, z.core.$strip>;
+declare const findFilters: {
+    name: "find-filters";
+    description: string;
+    parameters: {
+        search: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        filters: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            query: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                berry_red: "berry_red";
+                red: "red";
+                orange: "orange";
+                yellow: "yellow";
+                olive_green: "olive_green";
+                lime_green: "lime_green";
+                green: "green";
+                mint_green: "mint_green";
+                teal: "teal";
+                sky_blue: "sky_blue";
+                light_blue: "light_blue";
+                blue: "blue";
+                grape: "grape";
+                violet: "violet";
+                lavender: "lavender";
+                magenta: "magenta";
+                salmon: "salmon";
+                charcoal: "charcoal";
+                grey: "grey";
+                taupe: "taupe";
+            }>>>;
+            isFavorite: z.ZodBoolean;
+            itemOrder: z.ZodNumber;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        search?: string | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            filters: {
+                id: string;
+                name: string;
+                query: string;
+                description: string | undefined;
+                color: "berry_red" | "red" | "orange" | "yellow" | "olive_green" | "lime_green" | "green" | "mint_green" | "teal" | "sky_blue" | "light_blue" | "blue" | "grape" | "violet" | "lavender" | "magenta" | "salmon" | "charcoal" | "grey" | "taupe" | undefined;
+                isFavorite: boolean;
+                itemOrder: number;
+            }[];
+            totalCount: number;
+        };
+    }>;
+};
+export { FilterOutputSchema, findFilters };
+//# sourceMappingURL=find-filters.d.ts.map

package/dist/tools/find-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-filters.d.ts","sourceRoot":"","sources":["../../src/tools/find-filters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAatB,CAAA;AAOF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsC8C,CAAA;AA2B/D,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/find-labels.d.ts

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+declare const findLabels: {
+    name: "find-labels";
+    description: string;
+    parameters: {
+        searchText: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        cursor: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        labels: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            color: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+                berry_red: "berry_red";
+                red: "red";
+                orange: "orange";
+                yellow: "yellow";
+                olive_green: "olive_green";
+                lime_green: "lime_green";
+                green: "green";
+                mint_green: "mint_green";
+                teal: "teal";
+                sky_blue: "sky_blue";
+                light_blue: "light_blue";
+                blue: "blue";
+                grape: "grape";
+                violet: "violet";
+                lavender: "lavender";
+                magenta: "magenta";
+                salmon: "salmon";
+                charcoal: "charcoal";
+                grey: "grey";
+                taupe: "taupe";
+            }>>>;
+            order: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+            isFavorite: z.ZodBoolean;
+        }, z.core.$strip>>;
+        nextCursor: z.ZodOptional<z.ZodString>;
+        totalCount: z.ZodNumber;
+        hasMore: z.ZodBoolean;
+        sharedLabels: z.ZodArray<z.ZodString>;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        limit: number;
+        searchText?: string | undefined;
+        cursor?: string | undefined;
+    }, client: import('@doist/todoist-sdk').TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            labels: {
+                id: string;
+                name: string;
+                isFavorite: boolean;
+                color?: "berry_red" | "red" | "orange" | "yellow" | "olive_green" | "lime_green" | "green" | "mint_green" | "teal" | "sky_blue" | "light_blue" | "blue" | "grape" | "violet" | "lavender" | "magenta" | "salmon" | "charcoal" | "grey" | "taupe" | undefined;
+                order?: number | undefined;
+            }[];
+            nextCursor: string | undefined;
+            totalCount: number;
+            hasMore: boolean;
+            sharedLabels: string[];
+            appliedFilters: {
+                searchText: string;
+                limit?: undefined;
+                cursor?: undefined;
+            } | {
+                limit: number;
+                cursor: string | undefined;
+                searchText?: undefined;
+            };
+        };
+    }>;
+};
+export { findLabels };
+//# sourceMappingURL=find-labels.d.ts.map

package/dist/tools/find-labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-labels.d.ts","sourceRoot":"","sources":["../../src/tools/find-labels.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2CvB,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoC+C,CAAA;AAwD/D,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/tools/find-project-collaborators.d.ts

@@ -0,0 +1,94 @@
+import { TodoistApi } from '@doist/todoist-sdk';
+import { z } from 'zod';
+import { ProjectCollaborator } from '../utils/user-resolver.js';
+declare const findProjectCollaborators: {
+    name: "find-project-collaborators";
+    description: string;
+    parameters: {
+        projectId: z.ZodOptional<z.ZodString>;
+        searchTerm: z.ZodOptional<z.ZodString>;
+    };
+    outputSchema: {
+        collaborators: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            email: z.ZodString;
+        }, z.core.$strip>>;
+        projectInfo: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            isShared: z.ZodBoolean;
+        }, z.core.$strip>>;
+        totalCount: z.ZodNumber;
+        totalAvailable: z.ZodOptional<z.ZodNumber>;
+        appliedFilters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    annotations: {
+        readOnlyHint: true;
+        destructiveHint: false;
+        idempotentHint: true;
+    };
+    execute(args: {
+        projectId?: string | undefined;
+        searchTerm?: string | undefined;
+    }, client: TodoistApi): Promise<{
+        textContent: string;
+        structuredContent: {
+            collaborators: ProjectCollaborator[];
+            projectInfo: undefined;
+            totalCount: number;
+            totalAvailable: number;
+            appliedFilters: Record<string, unknown>;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: false;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId?: string | undefined;
+                searchTerm?: string | undefined;
+            };
+            totalAvailable?: undefined;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: true;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId?: string | undefined;
+                searchTerm?: string | undefined;
+            };
+            totalAvailable?: undefined;
+        };
+    } | {
+        textContent: string;
+        structuredContent: {
+            collaborators: ProjectCollaborator[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: true;
+            };
+            totalCount: number;
+            totalAvailable: number;
+            appliedFilters: {
+                projectId?: string | undefined;
+                searchTerm?: string | undefined;
+            };
+        };
+    }>;
+};
+export { findProjectCollaborators };
+//# sourceMappingURL=find-project-collaborators.d.ts.map

package/dist/tools/find-project-collaborators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-project-collaborators.d.ts","sourceRoot":"","sources":["../../src/tools/find-project-collaborators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACzE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,2BAA2B,CAAA;AAsClF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6FiC,CAAA;AA2J/D,OAAO,EAAE,wBAAwB,EAAE,CAAA"}