@doist/todoist-ai 4.1.0 → 4.5.1

package/dist/tools/__tests__/user-info.test.js

@@ -0,0 +1,139 @@
+import { jest } from '@jest/globals';
+import { extractStructuredContent, extractTextContent, TEST_ERRORS, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { userInfo } from '../user-info.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getUser: jest.fn(),
+};
+const { USER_INFO } = ToolNames;
+// Helper function to create a mock user with default values that can be overridden
+function createMockUser(overrides = {}) {
+    return {
+        id: '123',
+        fullName: 'Test User',
+        email: 'test@example.com',
+        isPremium: true,
+        completedToday: 12,
+        dailyGoal: 10,
+        weeklyGoal: 100,
+        startDay: 1, // Monday
+        tzInfo: {
+            timezone: 'Europe/Madrid',
+            gmtString: '+02:00',
+            hours: 2,
+            minutes: 0,
+            isDst: 1,
+        },
+        lang: 'en',
+        avatarBig: 'https://example.com/avatar.jpg',
+        avatarMedium: null,
+        avatarS640: null,
+        avatarSmall: null,
+        karma: 86394.0,
+        karmaTrend: 'up',
+        nextWeek: 1,
+        weekendStartDay: 6,
+        timeFormat: 0,
+        dateFormat: 0,
+        daysOff: [6, 7],
+        businessAccountId: null,
+        completedCount: 102920,
+        inboxProjectId: '6PVw8cMf7m8fWwRp',
+        startPage: 'overdue',
+        ...overrides,
+    };
+}
+describe(`${USER_INFO} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should generate user info with all required fields', async () => {
+        const mockUser = createMockUser();
+        mockTodoistApi.getUser.mockResolvedValue(mockUser);
+        const result = await userInfo.execute({}, mockTodoistApi);
+        expect(mockTodoistApi.getUser).toHaveBeenCalledWith();
+        // Test text content contains expected information
+        const textContent = extractTextContent(result);
+        expect(textContent).toContain('User ID:** 123');
+        expect(textContent).toContain('Test User');
+        expect(textContent).toContain('test@example.com');
+        expect(textContent).toContain('Europe/Madrid');
+        expect(textContent).toContain('Monday (1)');
+        expect(textContent).toContain('Completed Today:** 12');
+        expect(textContent).toContain('Plan:** Todoist Pro');
+        // Test structured content
+        const structuredContent = extractStructuredContent(result);
+        expect(structuredContent).toEqual(expect.objectContaining({
+            type: 'user_info',
+            userId: '123',
+            fullName: 'Test User',
+            email: 'test@example.com',
+            timezone: 'Europe/Madrid',
+            startDay: 1,
+            startDayName: 'Monday',
+            completedToday: 12,
+            dailyGoal: 10,
+            weeklyGoal: 100,
+            plan: 'Todoist Pro',
+            currentLocalTime: expect.any(String),
+            weekStartDate: expect.any(String),
+            weekEndDate: expect.any(String),
+            currentWeekNumber: expect.any(Number),
+        }));
+        // Verify date formats
+        expect(structuredContent.weekStartDate).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+        expect(structuredContent.weekEndDate).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+        expect(structuredContent.currentLocalTime).toMatch(/^\d{2}\/\d{2}\/\d{4}, \d{2}:\d{2}:\d{2}$/);
+    });
+    it('should handle missing timezone info', async () => {
+        const mockUser = createMockUser({
+            isPremium: false,
+            tzInfo: {
+                timezone: 'UTC',
+                gmtString: '+00:00',
+                hours: 0,
+                minutes: 0,
+                isDst: 0,
+            },
+        });
+        mockTodoistApi.getUser.mockResolvedValue(mockUser);
+        const result = await userInfo.execute({}, mockTodoistApi);
+        const textContent = extractTextContent(result);
+        expect(textContent).toContain('UTC'); // Should default to UTC
+        expect(textContent).toContain('Monday (1)'); // Should default to Monday
+        expect(textContent).toContain('Plan:** Todoist Free');
+        const structuredContent = extractStructuredContent(result);
+        expect(structuredContent.timezone).toBe('UTC');
+        expect(structuredContent.startDay).toBe(1);
+        expect(structuredContent.startDayName).toBe('Monday');
+        expect(structuredContent.plan).toBe('Todoist Free');
+    });
+    it('should handle invalid timezone and fallback to UTC', async () => {
+        const mockUser = createMockUser({
+            startDay: 2, // Tuesday
+            tzInfo: {
+                timezone: 'Invalid/Timezone',
+                gmtString: '+05:30',
+                hours: 5,
+                minutes: 30,
+                isDst: 0,
+            },
+        });
+        mockTodoistApi.getUser.mockResolvedValue(mockUser);
+        const result = await userInfo.execute({}, mockTodoistApi);
+        const textContent = extractTextContent(result);
+        expect(textContent).toContain('UTC'); // Should fallback to UTC
+        expect(textContent).toContain('Tuesday (2)');
+        const structuredContent = extractStructuredContent(result);
+        expect(structuredContent.timezone).toBe('UTC'); // Should be UTC, not the invalid timezone
+        expect(structuredContent.startDay).toBe(2);
+        expect(structuredContent.startDayName).toBe('Tuesday');
+        expect(structuredContent.currentLocalTime).toMatch(/^\d{2}\/\d{2}\/\d{4}, \d{2}:\d{2}:\d{2}$/);
+    });
+    it('should propagate API errors', async () => {
+        const apiError = new Error(TEST_ERRORS.API_UNAUTHORIZED);
+        mockTodoistApi.getUser.mockRejectedValue(apiError);
+        await expect(userInfo.execute({}, mockTodoistApi)).rejects.toThrow(TEST_ERRORS.API_UNAUTHORIZED);
+    });
+});

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

@@ -1,4 +1,3 @@
-import type { Comment } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
 declare const addComments: {
     name: "add-comments";
@@ -10,19 +9,19 @@ declare const addComments: {
             content: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             content: string;
-            projectId?: string | undefined;
             taskId?: string | undefined;
+            projectId?: string | undefined;
         }, {
             content: string;
-            projectId?: string | undefined;
             taskId?: string | undefined;
+            projectId?: string | undefined;
         }>, "many">;
     };
     execute(args: {
         comments: {
             content: string;
-            projectId?: string | undefined;
             taskId?: string | undefined;
+            projectId?: string | undefined;
         }[];
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
@@ -30,7 +29,31 @@ declare const addComments: {
             text: string;
         }[];
         structuredContent: {
-            comments: Comment[];
+            comments: {
+                taskId: string | undefined;
+                id: string;
+                content: string;
+                postedAt: string;
+                fileAttachment: {
+                    resourceType: string;
+                    fileName?: string | null | undefined;
+                    fileSize?: number | null | undefined;
+                    fileType?: string | null | undefined;
+                    fileUrl?: string | null | undefined;
+                    fileDuration?: number | null | undefined;
+                    uploadState?: "pending" | "completed" | null | undefined;
+                    image?: string | null | undefined;
+                    imageWidth?: number | null | undefined;
+                    imageHeight?: number | null | undefined;
+                    url?: string | null | undefined;
+                    title?: string | null | undefined;
+                } | null;
+                postedUid: string;
+                uidsToNotify: string[] | null;
+                reactions: Record<string, string[]> | null;
+                isDeleted: boolean;
+                projectId?: string | undefined;
+            }[];
             totalCount: number;
             addedCommentIds: string[];
         };

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

@@ -1 +1 @@
-{"version":3,"file":"add-comments.d.ts","sourceRoot":"","sources":["../../src/tools/add-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CyB,CAAA;AA6C1C,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"add-comments.d.ts","sourceRoot":"","sources":["../../src/tools/add-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAoFygV,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;CA1C98V,CAAA;AAyC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-comments.js

@@ -42,7 +42,7 @@ const addComments = {
         });
     },
 };
-function generateTextContent({ comments, }) {
+function generateTextContent({ comments }) {
     // Group comments by entity type and count
     const taskComments = comments.filter((c) => c.taskId).length;
     const projectComments = comments.filter((c) => c.projectId).length;

package/dist/tools/add-projects.d.ts

@@ -1,4 +1,3 @@
-import type { PersonalProject, WorkspaceProject } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
 declare const addProjects: {
     name: "add-projects";
@@ -30,7 +29,52 @@ declare const addProjects: {
             text: string;
         }[];
         structuredContent: {
-            projects: (PersonalProject | WorkspaceProject)[];
+            projects: ({
+                url: string;
+                id: string;
+                canAssignTasks: boolean;
+                childOrder: number;
+                color: string;
+                createdAt: string | null;
+                isArchived: boolean;
+                isDeleted: boolean;
+                isFavorite: boolean;
+                isFrozen: boolean;
+                name: string;
+                updatedAt: string | null;
+                viewStyle: string;
+                defaultOrder: number;
+                description: string;
+                isCollapsed: boolean;
+                isShared: boolean;
+                parentId: string | null;
+                inboxProject: boolean;
+            } | {
+                url: string;
+                id: string;
+                canAssignTasks: boolean;
+                childOrder: number;
+                color: string;
+                createdAt: string | null;
+                isArchived: boolean;
+                isDeleted: boolean;
+                isFavorite: boolean;
+                isFrozen: boolean;
+                name: string;
+                updatedAt: string | null;
+                viewStyle: string;
+                defaultOrder: number;
+                description: string;
+                isCollapsed: boolean;
+                isShared: boolean;
+                collaboratorRoleDefault: string;
+                folderId: string | null;
+                isInviteOnly: boolean | null;
+                isLinkSharingEnabled: boolean;
+                role: string | null;
+                status: string;
+                workspaceId: string;
+            })[];
             totalCount: number;
         };
     } | {

package/dist/tools/add-projects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-projects.d.ts","sourceRoot":"","sources":["../../src/tools/add-projects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AACtF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AAmC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"add-projects.d.ts","sourceRoot":"","sources":["../../src/tools/add-projects.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AA+B1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-projects.js

@@ -33,7 +33,7 @@ const addProjects = {
         });
     },
 };
-function generateTextContent({ projects, }) {
+function generateTextContent({ projects }) {
     const count = projects.length;
     const projectList = projects.map((project) => `• ${project.name} (id=${project.id})`).join('\n');
     const summary = `Added ${count} project${count === 1 ? '' : 's'}:\n${projectList}`;

package/dist/tools/add-sections.d.ts

@@ -1,4 +1,3 @@
-import type { Section } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
 declare const addSections: {
     name: "add-sections";
@@ -26,7 +25,20 @@ declare const addSections: {
             text: string;
         }[];
         structuredContent: {
-            sections: Section[];
+            sections: {
+                url: string;
+                id: string;
+                userId: string;
+                projectId: string;
+                addedAt: string;
+                updatedAt: string;
+                archivedAt: string | null;
+                name: string;
+                sectionOrder: number;
+                isArchived: boolean;
+                isDeleted: boolean;
+                isCollapsed: boolean;
+            }[];
             totalCount: number;
         };
     } | {

package/dist/tools/add-sections.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-sections.d.ts","sourceRoot":"","sources":["../../src/tools/add-sections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AAiD1C,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"add-sections.d.ts","sourceRoot":"","sources":["../../src/tools/add-sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgByB,CAAA;AA6C1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-sections.js

@@ -26,7 +26,7 @@ const addSections = {
         });
     },
 };
-function generateTextContent({ sections, }) {
+function generateTextContent({ sections }) {
     const count = sections.length;
     const sectionList = sections
         .map((section) => `• ${section.name} (id=${section.id}, projectId=${section.projectId})`)

package/dist/tools/add-tasks.d.ts

@@ -7,42 +7,46 @@ declare const addTasks: {
         tasks: z.ZodArray<z.ZodObject<{
             content: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
-            priority: z.ZodOptional<z.ZodNumber>;
+            priority: z.ZodOptional<z.ZodEnum<["p1", "p2", "p3", "p4"]>>;
             dueString: z.ZodOptional<z.ZodString>;
             duration: z.ZodOptional<z.ZodString>;
             projectId: z.ZodOptional<z.ZodString>;
             sectionId: z.ZodOptional<z.ZodString>;
             parentId: z.ZodOptional<z.ZodString>;
+            responsibleUser: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             content: string;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
-            priority?: number | undefined;
-            dueString?: string | undefined;
             duration?: string | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
+            dueString?: string | undefined;
+            responsibleUser?: string | undefined;
         }, {
             content: string;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
-            priority?: number | undefined;
-            dueString?: string | undefined;
             duration?: string | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
+            dueString?: string | undefined;
+            responsibleUser?: string | undefined;
         }>, "many">;
     };
     execute({ tasks }: {
         tasks: {
             content: string;
             description?: string | undefined;
-            parentId?: string | undefined;
             projectId?: string | undefined;
+            parentId?: string | undefined;
             sectionId?: string | undefined;
-            priority?: number | undefined;
-            dueString?: string | undefined;
             duration?: string | undefined;
+            priority?: "p1" | "p2" | "p3" | "p4" | undefined;
+            dueString?: string | undefined;
+            responsibleUser?: string | undefined;
         }[];
     }, client: TodoistApi): Promise<{
         content: {
@@ -62,6 +66,8 @@ declare const addTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             totalCount: number;
         };

package/dist/tools/add-tasks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgCvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsB4B,CAAA;AA8D1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"add-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/add-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAClF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA0CvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AA+H1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/add-tasks.js

@@ -1,13 +1,15 @@
 import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { mapTask } from '../tool-helpers.js';
+import { assignmentValidator } from '../utils/assignment-validator.js';
 import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
+import { convertPriorityToNumber, PrioritySchema } from '../utils/priorities.js';
 import { generateTaskNextSteps, getDateString, summarizeTaskOperation, } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const TaskSchema = z.object({
     content: z.string().min(1).describe('The content of the task to create.'),
     description: z.string().optional().describe('The description of the task.'),
-    priority: z.number().int().min(1).max(4).optional().describe('The priority of the task (1-4).'),
+    priority: PrioritySchema.optional().describe('The priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default).'),
     dueString: z.string().optional().describe('The due date for the task, in natural language.'),
     duration: z
         .string()
@@ -16,13 +18,17 @@ const TaskSchema = z.object({
     projectId: z.string().optional().describe('The project ID to add this task to.'),
     sectionId: z.string().optional().describe('The section ID to add this task to.'),
     parentId: z.string().optional().describe('The parent task ID (for subtasks).'),
+    responsibleUser: z
+        .string()
+        .optional()
+        .describe('Assign task to this user. Can be a user ID, name, or email address. User must be a collaborator on the target project.'),
 });
 const ArgsSchema = {
     tasks: z.array(TaskSchema).min(1).describe('The array of tasks to add.'),
 };
 const addTasks = {
     name: ToolNames.ADD_TASKS,
-    description: 'Add one or more tasks to a project, section, or parent.',
+    description: 'Add one or more tasks to a project, section, or parent. Supports assignment to project collaborators.',
     parameters: ArgsSchema,
     async execute({ tasks }, client) {
         const addTaskPromises = tasks.map((task) => processTask(task, client));
@@ -42,8 +48,16 @@ const addTasks = {
     },
 };
 async function processTask(task, client) {
-    const { duration: durationStr, projectId, sectionId, parentId, ...otherTaskArgs } = task;
+    const { duration: durationStr, projectId, sectionId, parentId, responsibleUser, priority, ...otherTaskArgs } = task;
     let taskArgs = { ...otherTaskArgs, projectId, sectionId, parentId };
+    // Handle priority conversion if provided
+    if (priority) {
+        taskArgs.priority = convertPriorityToNumber(priority);
+    }
+    // Prevent assignment to tasks without sufficient project context
+    if (!projectId && !sectionId && !parentId) {
+        throw new Error(`Task "${task.content}": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.`);
+    }
     // Parse duration if provided
     if (durationStr) {
         try {
@@ -61,6 +75,38 @@ async function processTask(task, client) {
             throw error;
         }
     }
+    // Handle assignment if provided
+    if (responsibleUser) {
+        // Resolve target project for validation
+        let targetProjectId = projectId;
+        if (!targetProjectId && parentId) {
+            // For subtasks, get project from parent task
+            try {
+                const parentTask = await client.getTask(parentId);
+                targetProjectId = parentTask.projectId;
+            }
+            catch (_error) {
+                throw new Error(`Task "${task.content}": Parent task "${parentId}" not found`);
+            }
+        }
+        else if (!targetProjectId && sectionId) {
+            // For section tasks, we need to find the project - this is a limitation
+            // For now, we'll require explicit projectId when using assignments with sections
+            throw new Error(`Task "${task.content}": When assigning tasks to sections, please also specify projectId`);
+        }
+        if (!targetProjectId) {
+            throw new Error(`Task "${task.content}": Cannot determine target project for assignment validation`);
+        }
+        // Validate assignment using comprehensive validator
+        const validation = await assignmentValidator.validateTaskCreationAssignment(client, targetProjectId, responsibleUser);
+        if (!validation.isValid) {
+            const errorMsg = validation.error?.message || 'Assignment validation failed';
+            const suggestions = validation.error?.suggestions?.join('. ') || '';
+            throw new Error(`Task "${task.content}": ${errorMsg}${suggestions ? `. ${suggestions}` : ''}`);
+        }
+        // Use the validated assignee ID
+        taskArgs.assigneeId = validation.resolvedUser?.userId;
+    }
     return await client.addTask(taskArgs);
 }
 function generateTextContent({ tasks, args, }) {

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

@@ -1,4 +1,3 @@
-import type { Comment } from '@doist/todoist-api-typescript';
 import { z } from 'zod';
 declare const findComments: {
     name: "find-comments";
@@ -11,10 +10,10 @@ declare const findComments: {
         limit: z.ZodOptional<z.ZodNumber>;
     };
     execute(args: {
-        projectId?: string | undefined;
         limit?: number | undefined;
-        cursor?: string | undefined;
         taskId?: string | undefined;
+        projectId?: string | undefined;
+        cursor?: string | undefined;
         commentId?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
@@ -22,7 +21,31 @@ declare const findComments: {
             text: string;
         }[];
         structuredContent: {
-            comments: Comment[];
+            comments: {
+                taskId: string | undefined;
+                id: string;
+                content: string;
+                postedAt: string;
+                fileAttachment: {
+                    resourceType: string;
+                    fileName?: string | null | undefined;
+                    fileSize?: number | null | undefined;
+                    fileType?: string | null | undefined;
+                    fileUrl?: string | null | undefined;
+                    fileDuration?: number | null | undefined;
+                    uploadState?: "pending" | "completed" | null | undefined;
+                    image?: string | null | undefined;
+                    imageWidth?: number | null | undefined;
+                    imageHeight?: number | null | undefined;
+                    url?: string | null | undefined;
+                    title?: string | null | undefined;
+                } | null;
+                postedUid: string;
+                uidsToNotify: string[] | null;
+                reactions: Record<string, string[]> | null;
+                isDeleted: boolean;
+                projectId?: string | undefined;
+            }[];
             searchType: string;
             searchId: string;
             hasMore: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAC5D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEwB,CAAA;AAoF1C,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA2J++P,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CArFr7Q,CAAA;AAoF1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

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

@@ -3,6 +3,8 @@ declare const findCompletedTasks: {
     name: "find-completed-tasks";
     description: string;
     parameters: {
+        labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        labelsOperator: z.ZodOptional<z.ZodEnum<["and", "or"]>>;
         getBy: z.ZodDefault<z.ZodEnum<["completion", "due"]>>;
         since: z.ZodString;
         until: z.ZodString;
@@ -15,14 +17,16 @@ declare const findCompletedTasks: {
     };
     execute(args: {
         limit: number;
-        getBy: "completion" | "due";
+        getBy: "due" | "completion";
         since: string;
         until: string;
+        projectId?: string | undefined;
         parentId?: string | undefined;
         workspaceId?: string | undefined;
-        projectId?: string | undefined;
         sectionId?: string | undefined;
+        labels?: string[] | undefined;
         cursor?: string | undefined;
+        labelsOperator?: "and" | "or" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -41,20 +45,24 @@ declare const findCompletedTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                getBy: "completion" | "due";
+                getBy: "due" | "completion";
                 since: string;
                 until: string;
+                projectId?: string | undefined;
                 parentId?: string | undefined;
                 workspaceId?: string | undefined;
-                projectId?: string | undefined;
                 sectionId?: string | undefined;
+                labels?: string[] | undefined;
                 cursor?: string | undefined;
+                labelsOperator?: "and" | "or" | undefined;
             };
         };
     } | {

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

@@ -1 +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;AA8CvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BkB,CAAA;AA2D1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}
+{"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;AAiDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCkB,CAAA;AAmE1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}