@doist/todoist-ai 4.4.0 → 4.5.1

package/dist/tools/__tests__/update-tasks.test.js

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_IDS, createMockTask, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+import { createMockTask, extractStructuredContent, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { updateTasks } from '../update-tasks.js';
 // Mock the Todoist API
@@ -109,13 +109,13 @@ describe(`${UPDATE_TASKS} tool`, () => {
                 tasks: [
                     {
                         id: '8485093749',
-                        priority: 3,
+                        priority: 'p3',
                         dueString: 'Aug 20',
                     },
                 ],
             }, mockTodoistApi);
             expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093749', {
-                priority: 3,
+                priority: 2,
                 dueString: 'Aug 20',
             });
             // Verify result structure
@@ -208,7 +208,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
                         id: '8485093752',
                         content: 'Completely updated task',
                         description: 'New description with details',
-                        priority: 4,
+                        priority: 'p4',
                         dueString: 'every Friday',
                         projectId: 'different-project-id',
                     },
@@ -222,7 +222,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
             expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093752', {
                 content: 'Completely updated task',
                 description: 'New description with details',
-                priority: 4,
+                priority: 1,
                 dueString: 'every Friday',
             });
             // Verify result structure
@@ -391,7 +391,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
             },
             {
                 error: 'API Error: Invalid priority value',
-                params: { id: '8485093748', priority: 5 },
+                params: { id: '8485093748', content: 'Test task' },
             },
         ])('should propagate $error', async ({ error, params }) => {
             mockTodoistApi.updateTask.mockRejectedValue(new Error(error));

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

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { TEST_ERRORS, extractStructuredContent, extractTextContent, } from '../../utils/test-helpers.js';
+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

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

@@ -9,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: {

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":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAwFggV,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;CA9Cr8V,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.map

@@ -1 +1 @@
-{"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;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.map

@@ -1 +1 @@
-{"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;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;
             duration?: string | undefined;
-            priority?: number | 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;
             duration?: string | undefined;
-            priority?: number | 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;
             duration?: string | undefined;
-            priority?: number | 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

@@ -10,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: {

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

@@ -20,9 +20,9 @@ declare const findCompletedTasks: {
         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;
@@ -45,6 +45,8 @@ declare const findCompletedTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
@@ -54,9 +56,9 @@ declare const findCompletedTasks: {
                 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;

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;AAiDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCkB,CAAA;AAmE1C,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"}

package/dist/tools/find-completed-tasks.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { mapTask } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
-import { LabelsSchema, generateLabelsFilter } from '../utils/labels.js';
+import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
 import { previewTasks, summarizeList } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
@@ -120,7 +120,7 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         limit: args.limit,
         nextCursor: nextCursor ?? undefined,
         filterHints,
-        previewLines: previewTasks(tasks),
+        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
         zeroReasonHints,
         nextSteps,
     });

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

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { type ProjectCollaborator } from '../utils/user-resolver.js';
+declare const findProjectCollaborators: {
+    name: "find-project-collaborators";
+    description: string;
+    parameters: {
+        projectId: z.ZodString;
+        searchTerm: z.ZodOptional<z.ZodString>;
+    };
+    execute(args: {
+        projectId: string;
+        searchTerm?: string | undefined;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            collaborators: never[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: boolean;
+            };
+            totalCount: number;
+            appliedFilters: {
+                projectId: string;
+                searchTerm?: string | undefined;
+            };
+        };
+    } | {
+        content: ({
+            type: "text";
+            text: string;
+            mimeType?: undefined;
+        } | {
+            type: "text";
+            mimeType: string;
+            text: string;
+        })[];
+        structuredContent?: undefined;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            collaborators: ProjectCollaborator[];
+            projectInfo: {
+                id: string;
+                name: string;
+                isShared: boolean;
+            };
+            totalCount: number;
+            totalAvailable: number;
+            appliedFilters: {
+                projectId: string;
+                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,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,OAAO,EAAE,KAAK,mBAAmB,EAAgB,MAAM,2BAA2B,CAAA;AAclF,QAAA,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FY,CAAA;AAwE1C,OAAO,EAAE,wBAAwB,EAAE,CAAA"}

package/dist/tools/find-project-collaborators.js

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+import { getToolOutput } from '../mcp-helpers.js';
+import { summarizeList } from '../utils/response-builders.js';
+import { ToolNames } from '../utils/tool-names.js';
+import { userResolver } from '../utils/user-resolver.js';
+const { FIND_PROJECTS, ADD_TASKS, UPDATE_TASKS } = ToolNames;
+const ArgsSchema = {
+    projectId: z.string().min(1).describe('The ID of the project to search for collaborators in.'),
+    searchTerm: z
+        .string()
+        .optional()
+        .describe('Search for a collaborator by name or email (partial and case insensitive match). If omitted, all collaborators in the project are returned.'),
+};
+const findProjectCollaborators = {
+    name: ToolNames.FIND_PROJECT_COLLABORATORS,
+    description: 'Search for collaborators by name or other criteria in a project.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        const { projectId, searchTerm } = args;
+        // First, validate that the project exists and get basic info
+        let projectName = projectId;
+        let project;
+        try {
+            project = await client.getProject(projectId);
+            if (!project) {
+                throw new Error(`Project with ID "${projectId}" not found or not accessible`);
+            }
+            projectName = project.name;
+            if (!project.isShared) {
+                const textContent = `Project "${projectName}" is not shared and has no collaborators.\n\n**Next steps:**\n• Share the project to enable collaboration\n• Use ${ADD_TASKS} and ${UPDATE_TASKS} for assignment features once shared`;
+                return getToolOutput({
+                    textContent,
+                    structuredContent: {
+                        collaborators: [],
+                        projectInfo: {
+                            id: projectId,
+                            name: projectName,
+                            isShared: false,
+                        },
+                        totalCount: 0,
+                        appliedFilters: args,
+                    },
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to access project "${projectId}": ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Get collaborators for the project
+        const allCollaborators = await userResolver.getProjectCollaborators(client, projectId);
+        if (allCollaborators.length === 0) {
+            const textContent = `Project "${projectName}" has no collaborators or collaborator data is not accessible.\n\n**Next steps:**\n• Check project sharing settings\n• Ensure you have permission to view collaborators\n• Try refreshing or re-sharing the project`;
+            return getToolOutput({
+                textContent,
+                structuredContent: {
+                    collaborators: [],
+                    projectInfo: {
+                        id: projectId,
+                        name: projectName,
+                        isShared: true,
+                    },
+                    totalCount: 0,
+                    appliedFilters: args,
+                },
+            });
+        }
+        // Filter collaborators if search term provided
+        let filteredCollaborators = allCollaborators;
+        if (searchTerm) {
+            const searchLower = searchTerm.toLowerCase().trim();
+            filteredCollaborators = allCollaborators.filter((collaborator) => collaborator.name.toLowerCase().includes(searchLower) ||
+                collaborator.email.toLowerCase().includes(searchLower));
+        }
+        const textContent = generateTextContent({
+            collaborators: filteredCollaborators,
+            projectName,
+            searchTerm,
+            totalAvailable: allCollaborators.length,
+        });
+        return getToolOutput({
+            textContent,
+            structuredContent: {
+                collaborators: filteredCollaborators,
+                projectInfo: {
+                    id: projectId,
+                    name: projectName,
+                    isShared: true,
+                },
+                totalCount: filteredCollaborators.length,
+                totalAvailable: allCollaborators.length,
+                appliedFilters: args,
+            },
+        });
+    },
+};
+function generateTextContent({ collaborators, projectName, searchTerm, totalAvailable, }) {
+    const subject = searchTerm
+        ? `Project collaborators matching "${searchTerm}"`
+        : 'Project collaborators';
+    const filterHints = [];
+    if (searchTerm) {
+        filterHints.push(`matching "${searchTerm}"`);
+    }
+    filterHints.push(`in project "${projectName}"`);
+    let previewLines = [];
+    if (collaborators.length > 0) {
+        previewLines = collaborators.slice(0, 10).map((collaborator) => {
+            const displayName = collaborator.name || 'Unknown Name';
+            const email = collaborator.email || 'No email';
+            return `• ${displayName} (${email}) - ID: ${collaborator.id}`;
+        });
+        if (collaborators.length > 10) {
+            previewLines.push(`... and ${collaborators.length - 10} more`);
+        }
+    }
+    const zeroReasonHints = [];
+    if (collaborators.length === 0) {
+        if (searchTerm) {
+            zeroReasonHints.push(`No collaborators match "${searchTerm}"`);
+            zeroReasonHints.push('Try a broader search term or check spelling');
+            if (totalAvailable > 0) {
+                zeroReasonHints.push(`${totalAvailable} collaborators available without filter`);
+            }
+        }
+        else {
+            zeroReasonHints.push('Project has no collaborators');
+            zeroReasonHints.push('Share the project to add collaborators');
+        }
+    }
+    const nextSteps = [];
+    if (collaborators.length > 0) {
+        nextSteps.push(`Use ${ADD_TASKS} with responsibleUser to assign new tasks`);
+        nextSteps.push(`Use ${UPDATE_TASKS} with responsibleUser to reassign existing tasks`);
+        nextSteps.push('Use collaborator names, emails, or IDs for assignments');
+    }
+    else {
+        nextSteps.push(`Use ${FIND_PROJECTS} to find other projects`);
+        if (searchTerm && totalAvailable > 0) {
+            nextSteps.push('Try searching without filters to see all collaborators');
+        }
+    }
+    return summarizeList({
+        subject,
+        count: collaborators.length,
+        filterHints,
+        previewLines: previewLines.join('\n'),
+        zeroReasonHints,
+        nextSteps,
+    });
+}
+export { findProjectCollaborators };

package/dist/tools/find-tasks-by-date.d.ts

@@ -35,6 +35,8 @@ declare const findTasksByDate: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;

package/dist/tools/find-tasks-by-date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA8CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDqB,CAAA;AAyE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}
+{"version":3,"file":"find-tasks-by-date.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks-by-date.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA8CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDqB,CAAA;AAyE1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/tools/find-tasks-by-date.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
 import { getTasksByFilter } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
-import { LabelsSchema, generateLabelsFilter } from '../utils/labels.js';
+import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
 import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const ArgsSchema = {
@@ -130,7 +130,7 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         limit: args.limit,
         nextCursor: nextCursor ?? undefined,
         filterHints,
-        previewLines: previewTasks(tasks),
+        previewLines: previewTasks(tasks, Math.min(tasks.length, args.limit)),
         zeroReasonHints,
         nextSteps,
     });

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

@@ -9,16 +9,18 @@ declare const findTasks: {
         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>;
     };
     execute(args: {
         limit: number;
-        parentId?: string | undefined;
         projectId?: string | undefined;
+        parentId?: string | undefined;
         sectionId?: string | undefined;
         labels?: string[] | undefined;
         cursor?: string | undefined;
+        responsibleUser?: string | undefined;
         labelsOperator?: "and" | "or" | undefined;
         searchText?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
@@ -39,17 +41,20 @@ declare const findTasks: {
                 parentId: string | null;
                 labels: string[];
                 duration: string | null;
+                responsibleUid: string | null;
+                assignedByUid: string | null;
             }[];
             nextCursor: string | null;
             totalCount: number;
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                parentId?: string | undefined;
                 projectId?: string | undefined;
+                parentId?: string | undefined;
                 sectionId?: string | undefined;
                 labels?: string[] | undefined;
                 cursor?: string | undefined;
+                responsibleUser?: string | undefined;
                 labelsOperator?: "and" | "or" | undefined;
                 searchText?: string | undefined;
             };