@doist/todoist-ai 4.15.0 → 4.16.0

package/dist/index.d.ts

@@ -605,7 +605,6 @@ declare const tools: {
             projects: import("zod").ZodArray<import("zod").ZodObject<{
                 id: import("zod").ZodString;
                 name: import("zod").ZodOptional<import("zod").ZodString>;
-                parentId: import("zod").ZodOptional<import("zod").ZodString>;
                 isFavorite: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 viewStyle: import("zod").ZodOptional<import("zod").ZodEnum<["list", "board", "calendar"]>>;
             }, "strip", import("zod").ZodTypeAny, {
@@ -613,13 +612,11 @@ declare const tools: {
                 name?: string | undefined;
                 isFavorite?: boolean | undefined;
                 viewStyle?: "list" | "board" | "calendar" | undefined;
-                parentId?: string | undefined;
             }, {
                 id: string;
                 name?: string | undefined;
                 isFavorite?: boolean | undefined;
                 viewStyle?: "list" | "board" | "calendar" | undefined;
-                parentId?: string | undefined;
             }>, "many">;
         };
         execute(args: {
@@ -628,7 +625,6 @@ declare const tools: {
                 name?: string | undefined;
                 isFavorite?: boolean | undefined;
                 viewStyle?: "list" | "board" | "calendar" | undefined;
-                parentId?: string | undefined;
             }[];
         }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
             content: {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAEzD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAExC,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AAEpE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAA;AAChF,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAE/C,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAqEqnX,CAAC;gCAA6C,CAAC;gCAA6C,CAAC;+BAA4C,CAAC;oCAAiD,CAAC;mCAAgD,CAAC;6BAA2D,CAAC;kCAA+C,CAAC;mCAAgD,CAAC;2BAAwC,CAAC;6BAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA9d,CAAC;gCAA6C,CAAC;gCAA6C,CAAC;+BAA4C,CAAC;oCAAiD,CAAC;mCAAgD,CAAC;6BAA2D,CAAC;kCAA+C,CAAC;mCAAgD,CAAC;2BAAwC,CAAC;6BAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAA9d,CAAC;gCAA6C,CAAC;gCAA6C,CAAC;+BAA4C,CAAC;oCAAiD,CAAC;mCAAgD,CAAC;6BAA2D,CAAC;kCAA+C,CAAC;mCAAgD,CAAC;2BAAwC,CAAC;6BAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CArC7lY,CAAA;AAED,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAA;AAE9B,OAAO,EAEH,QAAQ,EACR,aAAa,EACb,WAAW,EACX,SAAS,EACT,eAAe,EACf,kBAAkB,EAElB,WAAW,EACX,cAAc,EACd,YAAY,EAEZ,WAAW,EACX,cAAc,EACd,YAAY,EAEZ,WAAW,EACX,cAAc,EACd,YAAY,EAEZ,YAAY,EAEZ,WAAW,EACX,YAAY,EACZ,QAAQ,EAER,wBAAwB,EACxB,iBAAiB,EAEjB,MAAM,EACN,KAAK,GACR,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

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

@@ -1,10 +1,11 @@
 import { jest } from '@jest/globals';
-import { createMockTask, extractStructuredContent, extractTextContent, TODAY, } from '../../utils/test-helpers.js';
+import { createMockTask, createMockUser, extractStructuredContent, extractTextContent, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { addTasks } from '../add-tasks.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     addTask: jest.fn(),
+    getUser: jest.fn(),
 };
 const { ADD_TASKS, GET_OVERVIEW } = ToolNames;
 describe(`${ADD_TASKS} tool`, () => {
@@ -530,4 +531,76 @@ describe(`${ADD_TASKS} tool`, () => {
             }, mockTodoistApi)).rejects.toThrow('Task "Task with assignment but no project": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.');
         });
     });
+    describe('inbox project ID resolution', () => {
+        it('should resolve "inbox" to actual inbox project ID', async () => {
+            const mockUser = createMockUser({
+                inboxProjectId: TEST_IDS.PROJECT_INBOX,
+            });
+            const mockApiResponse = createMockTask({
+                id: '8485093760',
+                content: 'Task for inbox',
+                projectId: TEST_IDS.PROJECT_INBOX,
+                url: 'https://todoist.com/showTask?id=8485093760',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            // Mock the API calls
+            mockTodoistApi.getUser.mockResolvedValue(mockUser);
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            const result = await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task for inbox',
+                        projectId: 'inbox',
+                    },
+                ],
+            }, mockTodoistApi);
+            // Verify getUser was called to resolve inbox
+            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
+            // Verify addTask was called with resolved inbox project ID
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith({
+                content: 'Task for inbox',
+                projectId: TEST_IDS.PROJECT_INBOX,
+                sectionId: undefined,
+                parentId: undefined,
+                labels: undefined,
+            });
+            // Verify result contains the task
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.totalCount).toBe(1);
+            expect(structuredContent.tasks).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    id: '8485093760',
+                    projectId: TEST_IDS.PROJECT_INBOX,
+                }),
+            ]));
+        });
+        it('should not call getUser when projectId is not "inbox"', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093761',
+                content: 'Regular task',
+                projectId: '6cfCcrrCFg2xP94Q',
+                url: 'https://todoist.com/showTask?id=8485093761',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Regular task',
+                        projectId: '6cfCcrrCFg2xP94Q',
+                    },
+                ],
+            }, mockTodoistApi);
+            // Verify getUser was NOT called for regular project ID
+            expect(mockTodoistApi.getUser).not.toHaveBeenCalled();
+            // Verify addTask was called with original project ID
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith({
+                content: 'Regular task',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+                labels: undefined,
+            });
+        });
+    });
 });

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

@@ -1,5 +1,5 @@
 import { jest } from '@jest/globals';
-import { createMockTask, extractTextContent } from '../../utils/test-helpers.js';
+import { createMockTask, createMockUser, extractTextContent, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findCompletedTasks } from '../find-completed-tasks.js';
 // Mock the Todoist API
@@ -321,4 +321,103 @@ describe(`${FIND_COMPLETED_TASKS} tool`, () => {
             }, mockTodoistApi)).rejects.toThrow('API Error: Project not found');
         });
     });
+    describe('inbox project ID resolution', () => {
+        it('should resolve "inbox" to actual inbox project ID', async () => {
+            const mockUser = createMockUser({
+                inboxProjectId: TEST_IDS.PROJECT_INBOX,
+                tzInfo: {
+                    timezone: 'UTC',
+                    gmtString: '+00:00',
+                    hours: 0,
+                    minutes: 0,
+                    isDst: 0,
+                },
+            });
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093760',
+                    content: 'Completed inbox task',
+                    projectId: TEST_IDS.PROJECT_INBOX,
+                    completedAt: '2025-08-15T12:00:00Z',
+                    url: 'https://todoist.com/showTask?id=8485093760',
+                    addedAt: '2025-08-13T22:09:56.123456Z',
+                }),
+            ];
+            // Mock getUser to return our mock user with inbox ID
+            mockTodoistApi.getUser.mockResolvedValue(mockUser);
+            // Mock the API response
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
+                items: mockCompletedTasks,
+                nextCursor: null,
+            });
+            const result = await findCompletedTasks.execute({
+                getBy: 'completion',
+                since: '2025-08-15',
+                until: '2025-08-15',
+                projectId: 'inbox',
+                labels: [],
+                labelsOperator: 'or',
+                limit: 50,
+            }, mockTodoistApi);
+            // Verify getUser was called
+            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
+            // Verify getCompletedTasksByCompletionDate was called with resolved inbox project ID
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith(expect.objectContaining({
+                projectId: TEST_IDS.PROJECT_INBOX,
+                since: '2025-08-15T00:00:00.000Z',
+                until: '2025-08-15T23:59:59.000Z',
+                limit: 50,
+            }));
+            // Verify result contains the completed tasks
+            const textContent = extractTextContent(result);
+            expect(textContent).toContain('Completed tasks');
+            expect(textContent).toContain('Completed inbox task');
+        });
+        it('should use regular project ID when not "inbox"', async () => {
+            const mockUser = createMockUser({
+                tzInfo: {
+                    timezone: 'UTC',
+                    gmtString: '+00:00',
+                    hours: 0,
+                    minutes: 0,
+                    isDst: 0,
+                },
+            });
+            const mockCompletedTasks = [
+                createMockTask({
+                    id: '8485093761',
+                    content: 'Completed regular task',
+                    projectId: '6cfCcrrCFg2xP94Q',
+                    completedAt: '2025-08-15T12:00:00Z',
+                    url: 'https://todoist.com/showTask?id=8485093761',
+                    addedAt: '2025-08-13T22:09:56.123456Z',
+                }),
+            ];
+            // Mock getUser (will be called for timezone, but inbox resolution won't happen)
+            mockTodoistApi.getUser.mockResolvedValue(mockUser);
+            // Mock the API response
+            mockTodoistApi.getCompletedTasksByCompletionDate.mockResolvedValue({
+                items: mockCompletedTasks,
+                nextCursor: null,
+            });
+            await findCompletedTasks.execute({
+                getBy: 'completion',
+                since: '2025-08-15',
+                until: '2025-08-15',
+                projectId: '6cfCcrrCFg2xP94Q',
+                labels: [],
+                labelsOperator: 'or',
+                limit: 50,
+            }, mockTodoistApi);
+            // Verify getUser was called (for timezone info)
+            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
+            // Verify getCompletedTasksByCompletionDate was called with original project ID
+            expect(mockTodoistApi.getCompletedTasksByCompletionDate).toHaveBeenCalledWith(expect.objectContaining({
+                projectId: '6cfCcrrCFg2xP94Q',
+                since: '2025-08-15T00:00:00.000Z',
+                until: '2025-08-15T23:59:59.000Z',
+                limit: 50,
+            }));
+        });
+    });
 });

package/dist/tools/__tests__/find-sections.test.js

@@ -1,10 +1,11 @@
 import { jest } from '@jest/globals';
-import { createMockSection, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
+import { createMockSection, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findSections } from '../find-sections.js';
 // Mock the Todoist API
 const mockTodoistApi = {
     getSections: jest.fn(),
+    getUser: jest.fn(),
 };
 const { FIND_SECTIONS, ADD_SECTIONS } = ToolNames;
 describe(`${FIND_SECTIONS} tool`, () => {
@@ -232,6 +233,73 @@ describe(`${FIND_SECTIONS} tool`, () => {
             expect(textContent).toContain('Done Soon • id=');
         });
     });
+    describe('inbox project ID resolution', () => {
+        it('should resolve "inbox" to actual inbox project ID', async () => {
+            const mockUser = createMockUser({
+                inboxProjectId: TEST_IDS.PROJECT_INBOX,
+            });
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_INBOX,
+                    name: 'Inbox Section 1',
+                }),
+                createMockSection({
+                    id: TEST_IDS.SECTION_2,
+                    projectId: TEST_IDS.PROJECT_INBOX,
+                    name: 'Inbox Section 2',
+                    sectionOrder: 2,
+                }),
+            ];
+            // Mock getUser to return our mock user with inbox ID
+            mockTodoistApi.getUser.mockResolvedValue(mockUser);
+            // Mock the API response
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            const result = await findSections.execute({ projectId: 'inbox' }, mockTodoistApi);
+            // Verify getUser was called to resolve inbox
+            expect(mockTodoistApi.getUser).toHaveBeenCalledTimes(1);
+            // Verify getSections was called with resolved inbox project ID
+            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
+                projectId: TEST_IDS.PROJECT_INBOX,
+            });
+            // Verify result contains the sections
+            const textContent = extractTextContent(result);
+            expect(textContent).toContain('Sections in project');
+            expect(textContent).toContain('Inbox Section 1');
+            expect(textContent).toContain('Inbox Section 2');
+            // Verify structured content
+            const structuredContent = extractStructuredContent(result);
+            expect(structuredContent.totalCount).toBe(2);
+            expect(structuredContent.sections).toEqual([
+                { id: TEST_IDS.SECTION_1, name: 'Inbox Section 1' },
+                { id: TEST_IDS.SECTION_2, name: 'Inbox Section 2' },
+            ]);
+        });
+        it('should not call getUser when projectId is not "inbox"', async () => {
+            const mockSections = [
+                createMockSection({
+                    id: TEST_IDS.SECTION_1,
+                    projectId: TEST_IDS.PROJECT_TEST,
+                    name: 'Regular Section',
+                }),
+            ];
+            // Mock the API response
+            mockTodoistApi.getSections.mockResolvedValue({
+                results: mockSections,
+                nextCursor: null,
+            });
+            await findSections.execute({ projectId: TEST_IDS.PROJECT_TEST }, mockTodoistApi);
+            // Verify getUser was NOT called for regular project ID
+            expect(mockTodoistApi.getUser).not.toHaveBeenCalled();
+            // Verify getSections was called with original project ID
+            expect(mockTodoistApi.getSections).toHaveBeenCalledWith({
+                projectId: TEST_IDS.PROJECT_TEST,
+            });
+        });
+    });
     describe('error handling', () => {
         it.each([
             { error: 'API Error: Project not found', projectId: 'non-existent-project' },

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

@@ -104,24 +104,6 @@ describe(`${UPDATE_PROJECTS} tool`, () => {
             expect(textContent).toContain('Updated 1 project:');
             expect(textContent).toContain('Updated Favorite Project (id=project-123)');
         });
-        it('should update project with parentId to move it to a sub-project', async () => {
-            const mockApiResponse = createMockProject({
-                id: 'project-child',
-                name: 'Child Project',
-                parentId: 'project-parent',
-            });
-            mockTodoistApi.updateProject.mockResolvedValue(mockApiResponse);
-            const result = await updateProjects.execute({
-                projects: [{ id: 'project-child', parentId: 'project-parent' }],
-            }, mockTodoistApi);
-            expect(mockTodoistApi.updateProject).toHaveBeenCalledWith('project-child', {
-                parentId: 'project-parent',
-            });
-            const textContent = extractTextContent(result);
-            expect(textContent).toMatchSnapshot();
-            expect(textContent).toContain('Updated 1 project:');
-            expect(textContent).toContain('Child Project (id=project-child)');
-        });
     });
     describe('updating multiple projects', () => {
         it('should update multiple projects and return mapped results', async () => {

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"add-comments.d.ts","sourceRoot":"","sources":["../../src/tools/add-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA2F89T,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;CA1Cn6U,CAAA;AAyC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-comments.js

@@ -5,7 +5,10 @@ import { ToolNames } from '../utils/tool-names.js';
 const { FIND_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
 const CommentSchema = z.object({
     taskId: z.string().optional().describe('The ID of the task to comment on.'),
-    projectId: z.string().optional().describe('The ID of the project to comment on.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('The ID of the project to comment on. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     content: z.string().min(1).describe('The content of the comment.'),
 });
 const ArgsSchema = {
@@ -26,10 +29,17 @@ const addComments = {
                 throw new Error(`Comment ${index + 1}: Cannot provide both taskId and projectId. Choose one.`);
             }
         }
-        const addCommentPromises = comments.map(async ({ content, taskId, projectId }) => await client.addComment({
-            content,
-            ...(taskId ? { taskId } : { projectId }),
-        }));
+        // Check if any comment needs inbox resolution
+        const needsInboxResolution = comments.some((comment) => comment.projectId === 'inbox');
+        const todoistUser = needsInboxResolution ? await client.getUser() : null;
+        const addCommentPromises = comments.map(async ({ content, taskId, projectId }) => {
+            // Resolve "inbox" to actual inbox project ID if needed
+            const resolvedProjectId = projectId === 'inbox' && todoistUser ? todoistUser.inboxProjectId : projectId;
+            return await client.addComment({
+                content,
+                ...(taskId ? { taskId } : { projectId: resolvedProjectId }),
+            });
+        });
         const newComments = await Promise.all(addCommentPromises);
         const textContent = generateTextContent({ comments: newComments });
         return getToolOutput({

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;AA6C1C,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;AAsBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+ByB,CAAA;AA6C1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/add-sections.js

@@ -5,7 +5,10 @@ import { ToolNames } from '../utils/tool-names.js';
 const { ADD_TASKS, FIND_TASKS, GET_OVERVIEW, FIND_SECTIONS } = ToolNames;
 const SectionSchema = z.object({
     name: z.string().min(1).describe('The name of the section.'),
-    projectId: z.string().min(1).describe('The ID of the project to add the section to.'),
+    projectId: z
+        .string()
+        .min(1)
+        .describe('The ID of the project to add the section to. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
 });
 const ArgsSchema = {
     sections: z.array(SectionSchema).min(1).describe('The array of sections to add.'),
@@ -15,7 +18,17 @@ const addSections = {
     description: 'Add one or more new sections to projects.',
     parameters: ArgsSchema,
     async execute({ sections }, client) {
-        const newSections = await Promise.all(sections.map((section) => client.addSection(section)));
+        // Check if any section needs inbox resolution
+        const needsInboxResolution = sections.some((section) => section.projectId === 'inbox');
+        const todoistUser = needsInboxResolution ? await client.getUser() : null;
+        // Resolve inbox project IDs
+        const sectionsWithResolvedProjectIds = sections.map((section) => ({
+            ...section,
+            projectId: section.projectId === 'inbox' && todoistUser
+                ? todoistUser.inboxProjectId
+                : section.projectId,
+        }));
+        const newSections = await Promise.all(sectionsWithResolvedProjectIds.map((section) => client.addSection(section)));
         const textContent = generateTextContent({ sections: newSections });
         return getToolOutput({
             textContent,

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;AA2DvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AAwI1C,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;AAgEvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AA+I1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/add-tasks.js

@@ -26,7 +26,10 @@ const TaskSchema = z.object({
         .optional()
         .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
     labels: z.array(z.string()).optional().describe('The labels to attach to the task.'),
-    projectId: z.string().optional().describe('The project ID to add this task to.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('The project ID to add this task to. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     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
@@ -60,9 +63,15 @@ const addTasks = {
 };
 async function processTask(task, client) {
     const { duration: durationStr, projectId, sectionId, parentId, responsibleUser, priority, labels, deadlineDate, ...otherTaskArgs } = task;
+    // Resolve "inbox" to actual inbox project ID if needed
+    let resolvedProjectId = projectId;
+    if (projectId === 'inbox') {
+        const todoistUser = await client.getUser();
+        resolvedProjectId = todoistUser.inboxProjectId;
+    }
     let taskArgs = {
         ...otherTaskArgs,
-        projectId,
+        projectId: resolvedProjectId,
         sectionId,
         parentId,
         labels,
@@ -73,7 +82,7 @@ async function processTask(task, client) {
         taskArgs.priority = convertPriorityToNumber(priority);
     }
     // Only prevent assignment (not task creation) without sufficient project context
-    if (responsibleUser && !projectId && !sectionId && !parentId) {
+    if (responsibleUser && !resolvedProjectId && !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
@@ -96,7 +105,7 @@ async function processTask(task, client) {
     // Handle assignment if provided
     if (responsibleUser) {
         // Resolve target project for validation
-        let targetProjectId = projectId;
+        let targetProjectId = resolvedProjectId;
         if (!targetProjectId && parentId) {
             // For subtasks, get project from parent task
             try {

package/dist/tools/find-activity.js

@@ -57,7 +57,7 @@ const findActivity = {
         // Add optional filters
         if (objectType)
             apiArgs.objectType = objectType;
-        if (objectId)
+        if (objectId && objectId !== 'remove')
             apiArgs.objectId = objectId;
         if (eventType)
             apiArgs.eventType = eventType;

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":"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"}
+{"version":3,"file":"find-comments.d.ts","sourceRoot":"","sources":["../../src/tools/find-comments.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4BvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BA+JyqP,CAAC;4BAA6C,CAAC;4BAA6C,CAAC;2BAA4C,CAAC;gCAAiD,CAAC;+BAAgD,CAAC;yBAA2D,CAAC;8BAA+C,CAAC;+BAAgD,CAAC;uBAAwC,CAAC;yBAA0C,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;CArF/mQ,CAAA;AAoF1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-comments.js

@@ -6,7 +6,10 @@ import { ToolNames } from '../utils/tool-names.js';
 const { ADD_COMMENTS, UPDATE_COMMENTS, DELETE_OBJECT } = ToolNames;
 const ArgsSchema = {
     taskId: z.string().optional().describe('Find comments for a specific task.'),
-    projectId: z.string().optional().describe('Find comments for a specific project.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('Find comments for a specific project. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     commentId: z.string().optional().describe('Get a specific comment by ID.'),
     cursor: z.string().optional().describe('Pagination cursor for retrieving more results.'),
     limit: z
@@ -30,6 +33,8 @@ const findComments = {
         if (searchParams.length > 1) {
             throw new Error('Cannot provide multiple search parameters. Choose one of: taskId, projectId, or commentId.');
         }
+        // Resolve "inbox" to actual inbox project ID if needed
+        const resolvedProjectId = args.projectId === 'inbox' ? (await client.getUser()).inboxProjectId : args.projectId;
         let comments;
         let hasMore = false;
         let nextCursor = null;
@@ -49,10 +54,10 @@ const findComments = {
             hasMore = response.nextCursor !== null;
             nextCursor = response.nextCursor;
         }
-        else if (args.projectId) {
+        else if (resolvedProjectId) {
             // Get comments by project
             const response = await client.getComments({
-                projectId: args.projectId,
+                projectId: resolvedProjectId,
                 cursor: args.cursor || null,
                 limit: args.limit || ApiLimits.COMMENTS_DEFAULT,
             });

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;AAwDvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEkB,CAAA;AA2E1C,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;AA6DvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEkB,CAAA;AA2E1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

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

@@ -23,7 +23,10 @@ const ArgsSchema = {
         .regex(/^\d{4}-\d{2}-\d{2}$/)
         .describe('The start date to get the tasks for. Format: YYYY-MM-DD.'),
     workspaceId: z.string().optional().describe('The ID of the workspace to get the tasks for.'),
-    projectId: z.string().optional().describe('The ID of the project to get the tasks for.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('The ID of the project to get the tasks for. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     sectionId: z.string().optional().describe('The ID of the section to get the tasks for.'),
     parentId: z.string().optional().describe('The ID of the parent task to get the tasks for.'),
     responsibleUser: z
@@ -48,7 +51,7 @@ const findCompletedTasks = {
     description: 'Get completed tasks (includes all collaborators by default—use responsibleUser to narrow).',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { getBy, labels, labelsOperator, since, until, responsibleUser, ...rest } = args;
+        const { getBy, labels, labelsOperator, since, until, responsibleUser, projectId, ...rest } = args;
         // Resolve assignee name to user ID if provided
         const resolved = await resolveResponsibleUser(client, responsibleUser);
         const assigneeEmail = resolved?.email;
@@ -61,6 +64,8 @@ const findCompletedTasks = {
         // Get user timezone to convert local dates to UTC
         const user = await client.getUser();
         const userGmtOffset = user.tzInfo?.gmtString || '+00:00';
+        // Resolve "inbox" to actual inbox project ID if needed
+        const resolvedProjectId = projectId === 'inbox' ? user.inboxProjectId : projectId;
         // Convert user's local date to UTC timestamps
         // This ensures we capture the entire day from the user's perspective
         const sinceWithOffset = `${since}T00:00:00${userGmtOffset}`;
@@ -71,12 +76,14 @@ const findCompletedTasks = {
         const { items, nextCursor } = getBy === 'completion'
             ? await client.getCompletedTasksByCompletionDate({
                 ...rest,
+                projectId: resolvedProjectId,
                 since: sinceDateTime,
                 until: untilDateTime,
                 ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),
             })
             : await client.getCompletedTasksByDueDate({
                 ...rest,
+                projectId: resolvedProjectId,
                 since: sinceDateTime,
                 until: untilDateTime,
                 ...(filterQuery ? { filterQuery, filterLang: 'en' } : {}),

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

@@ -1 +1 @@
-{"version":3,"file":"find-sections.d.ts","sourceRoot":"","sources":["../../src/tools/find-sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCwB,CAAA;AAqE1C,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"find-sections.d.ts","sourceRoot":"","sources":["../../src/tools/find-sections.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA4BvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCwB,CAAA;AAqE1C,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/tools/find-sections.js

@@ -4,7 +4,10 @@ import { summarizeList } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const { ADD_SECTIONS, UPDATE_SECTIONS, FIND_TASKS, UPDATE_TASKS, DELETE_OBJECT } = ToolNames;
 const ArgsSchema = {
-    projectId: z.string().min(1).describe('The ID of the project to search sections in.'),
+    projectId: z
+        .string()
+        .min(1)
+        .describe('The ID of the project to search sections in. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     search: z
         .string()
         .optional()
@@ -15,8 +18,10 @@ const findSections = {
     description: 'Search for sections by name or other criteria in a project.',
     parameters: ArgsSchema,
     async execute(args, client) {
+        // Resolve "inbox" to actual inbox project ID if needed
+        const resolvedProjectId = args.projectId === 'inbox' ? (await client.getUser()).inboxProjectId : args.projectId;
         const { results } = await client.getSections({
-            projectId: args.projectId,
+            projectId: resolvedProjectId,
         });
         const searchLower = args.search ? args.search.toLowerCase() : undefined;
         const filtered = searchLower

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

@@ -1 +1 @@
-{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAsDvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqL2B,CAAA;AA2K1C,OAAO,EAAE,SAAS,EAAE,CAAA"}
+{"version":3,"file":"find-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/find-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2DvB,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwL2B,CAAA;AA2K1C,OAAO,EAAE,SAAS,EAAE,CAAA"}

package/dist/tools/find-tasks.js

@@ -9,7 +9,10 @@ import { ToolNames } from '../utils/tool-names.js';
 const { FIND_COMPLETED_TASKS, ADD_TASKS } = ToolNames;
 const ArgsSchema = {
     searchText: z.string().optional().describe('The text to search for in tasks.'),
-    projectId: z.string().optional().describe('Find tasks in this project.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('Find tasks in this project. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     sectionId: z.string().optional().describe('Find tasks in this section.'),
     parentId: z.string().optional().describe('Find subtasks of this parent task.'),
     responsibleUser: z
@@ -60,8 +63,10 @@ const findTasks = {
                 limit,
                 cursor: cursor ?? null,
             };
-            if (projectId)
-                taskParams.projectId = projectId;
+            if (projectId) {
+                taskParams.projectId =
+                    projectId === 'inbox' ? todoistUser.inboxProjectId : projectId;
+            }
             if (sectionId)
                 taskParams.sectionId = sectionId;
             if (parentId)

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

@@ -6,7 +6,6 @@ declare const updateProjects: {
         projects: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodOptional<z.ZodString>;
-            parentId: z.ZodOptional<z.ZodString>;
             isFavorite: z.ZodOptional<z.ZodBoolean>;
             viewStyle: z.ZodOptional<z.ZodEnum<["list", "board", "calendar"]>>;
         }, "strip", z.ZodTypeAny, {
@@ -14,13 +13,11 @@ declare const updateProjects: {
             name?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
-            parentId?: string | undefined;
         }, {
             id: string;
             name?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
-            parentId?: string | undefined;
         }>, "many">;
     };
     execute(args: {
@@ -29,7 +26,6 @@ declare const updateProjects: {
             name?: string | undefined;
             isFavorite?: boolean | undefined;
             viewStyle?: "list" | "board" | "calendar" | undefined;
-            parentId?: string | undefined;
         }[];
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {

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

@@ -1 +1 @@
-{"version":3,"file":"update-projects.d.ts","sourceRoot":"","sources":["../../src/tools/update-projects.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA2BvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCsB,CAAA;AAuD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"update-projects.d.ts","sourceRoot":"","sources":["../../src/tools/update-projects.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCsB,CAAA;AAuD1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/update-projects.js

@@ -6,10 +6,6 @@ const { FIND_PROJECTS, FIND_TASKS, GET_OVERVIEW } = ToolNames;
 const ProjectUpdateSchema = z.object({
     id: z.string().min(1).describe('The ID of the project to update.'),
     name: z.string().min(1).optional().describe('The new name of the project.'),
-    parentId: z
-        .string()
-        .optional()
-        .describe('The ID of the parent project. If provided, moves this project to be a sub-project.'),
     isFavorite: z.boolean().optional().describe('Whether the project is a favorite.'),
     viewStyle: z.enum(['list', 'board', 'calendar']).optional().describe('The project view style.'),
 });

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

@@ -1 +1 @@
-{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAmEvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8HyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"update-tasks.d.ts","sourceRoot":"","sources":["../../src/tools/update-tasks.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwEvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqIyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/update-tasks.js

@@ -17,7 +17,10 @@ const TasksUpdateSchema = z.object({
         .string()
         .optional()
         .describe('New additional details, notes, or context for the task. Use this for longer content rather than putting it in the task name. Supports Markdown.'),
-    projectId: z.string().optional().describe('The new project ID for the task.'),
+    projectId: z
+        .string()
+        .optional()
+        .describe('The new project ID for the task. Project ID should be an ID string, or the text "inbox", for inbox tasks.'),
     sectionId: z.string().optional().describe('The new section ID for the task.'),
     parentId: z.string().optional().describe('The new parent task ID (for subtasks).'),
     order: z.number().optional().describe('The new order of the task within its parent/section.'),
@@ -57,6 +60,12 @@ const updateTasks = {
                 return undefined;
             }
             const { id, projectId, sectionId, parentId, duration: durationStr, responsibleUser, priority, labels, deadlineDate, ...otherUpdateArgs } = task;
+            // Resolve "inbox" to actual inbox project ID if needed
+            let resolvedProjectId = projectId;
+            if (projectId === 'inbox') {
+                const todoistUser = await client.getUser();
+                resolvedProjectId = todoistUser.inboxProjectId;
+            }
             let updateArgs = {
                 ...otherUpdateArgs,
                 ...(labels !== undefined && { labels }),
@@ -112,10 +121,10 @@ const updateTasks = {
                 }
             }
             // If no move parameters are provided, use updateTask without moveTask
-            if (!projectId && !sectionId && !parentId) {
+            if (!resolvedProjectId && !sectionId && !parentId) {
                 return await client.updateTask(id, updateArgs);
             }
-            const moveArgs = createMoveTaskArgs(id, projectId, sectionId, parentId);
+            const moveArgs = createMoveTaskArgs(id, resolvedProjectId, sectionId, parentId);
             const movedTask = await client.moveTask(id, moveArgs);
             if (Object.keys(updateArgs).length > 0) {
                 return await client.updateTask(id, updateArgs);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "4.15.0",
+    "version": "4.16.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -40,19 +40,20 @@
         "lint:write": "biome lint --write",
         "format:check": "biome format",
         "format:write": "biome format --write",
-        "check": "biome check",
+        "lint:schemas": "npm run build && npx tsc scripts/validate-schemas.ts --outDir dist/scripts --moduleResolution node --module ESNext --target es2021 --esModuleInterop --skipLibCheck --declaration false && node dist/scripts/validate-schemas.js",
+        "check": "biome check && npm run lint:schemas",
         "check:fix": "biome check --fix --unsafe",
         "prepare": "husky"
     },
     "dependencies": {
+        "@doist/todoist-api-typescript": "6.0.0",
         "@modelcontextprotocol/sdk": "^1.11.1",
         "date-fns": "^4.1.0",
-        "@doist/todoist-api-typescript": "5.7.1",
         "dotenv": "^17.0.0",
         "zod": "^3.25.7"
     },
     "devDependencies": {
-        "@biomejs/biome": "2.2.6",
+        "@biomejs/biome": "2.3.2",
         "@types/express": "^5.0.2",
         "@types/jest": "30.0.0",
         "@types/morgan": "^1.9.9",
@@ -71,6 +72,15 @@
     "lint-staged": {
         "*": [
             "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true"
+        ],
+        "src/tools/*.ts": [
+            "npm run lint:schemas"
+        ],
+        "src/index.ts": [
+            "npm run lint:schemas"
+        ],
+        "scripts/validate-schemas.ts": [
+            "npm run lint:schemas"
         ]
     }
 }

package/scripts/validate-schemas.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+
+/**
+ * Schema Validation Script for Todoist AI MCP Server
+ *
+ * This script validates that all tool parameter schemas follow Gemini API compatibility rules.
+ * Specifically, it checks that no Zod string schemas use both .nullable() and .optional().
+ *
+ * This version imports the actual tools from the compiled index.js and validates their
+ * runtime Zod schemas for maximum accuracy.
+ *
+ * Usage:
+ *   npm run build && node scripts/validate-schemas.js
+ *   npm run build && node scripts/validate-schemas.js --verbose
+ *   npm run build && node scripts/validate-schemas.js --json
+ */
+
+import { z } from 'zod'
+
+interface ValidationIssue {
+    toolName: string
+    parameterPath: string
+    issue: string
+    suggestion: string
+}
+
+interface ValidationResult {
+    success: boolean
+    issues: ValidationIssue[]
+    toolsChecked: number
+    parametersChecked: number
+}
+
+/**
+ * Recursively walk a Zod schema and detect problematic patterns
+ */
+function walkZodSchema(
+    schema: z.ZodTypeAny,
+    path: string,
+    issues: ValidationIssue[],
+    toolName: string,
+): void {
+    const typeName = schema._def.typeName
+
+    // Check for ZodOptional containing a ZodNullable ZodString
+    if (typeName === 'ZodOptional') {
+        const innerSchema = schema._def.innerType
+        if (innerSchema._def.typeName === 'ZodNullable') {
+            const nullableInner = innerSchema._def.innerType
+            if (nullableInner._def.typeName === 'ZodString') {
+                issues.push({
+                    toolName,
+                    parameterPath: path,
+                    issue: 'GEMINI_API_INCOMPATIBLE: z.string().nullable().optional() pattern detected',
+                    suggestion:
+                        'REQUIRED FIX: Change "z.string().nullable().optional()" to "z.string().optional()" and use special strings like "remove" or "unassign" in description to handle clearing. This pattern causes HTTP 400 errors in Google Gemini API due to OpenAPI 3.1 nullable type incompatibility.',
+                })
+            }
+        }
+    }
+
+    // Check for ZodNullable containing a ZodOptional ZodString
+    if (typeName === 'ZodNullable') {
+        const innerSchema = schema._def.innerType
+        if (innerSchema._def.typeName === 'ZodOptional') {
+            const optionalInner = innerSchema._def.innerType
+            if (optionalInner._def.typeName === 'ZodString') {
+                issues.push({
+                    toolName,
+                    parameterPath: path,
+                    issue: 'GEMINI_API_INCOMPATIBLE: z.string().optional().nullable() pattern detected',
+                    suggestion:
+                        'REQUIRED FIX: Change "z.string().optional().nullable()" to "z.string().optional()" and use special strings like "remove" or "unassign" in description to handle clearing. This pattern causes HTTP 400 errors in Google Gemini API due to OpenAPI 3.1 nullable type incompatibility.',
+                })
+            }
+        }
+    }
+
+    // Recursively check nested schemas
+    switch (typeName) {
+        case 'ZodObject': {
+            const shape = schema._def.shape()
+            for (const [key, value] of Object.entries(shape)) {
+                const newPath = path ? `${path}.${key}` : key
+                walkZodSchema(value as z.ZodTypeAny, newPath, issues, toolName)
+            }
+            break
+        }
+        case 'ZodArray':
+            walkZodSchema(schema._def.type, `${path}[]`, issues, toolName)
+            break
+
+        case 'ZodOptional':
+        case 'ZodNullable':
+        case 'ZodDefault':
+            walkZodSchema(schema._def.innerType, path, issues, toolName)
+            break
+
+        case 'ZodUnion':
+        case 'ZodDiscriminatedUnion': {
+            const options = schema._def.options || schema._def.discriminatedUnion
+            if (Array.isArray(options)) {
+                options.forEach((option: z.ZodTypeAny, index: number) => {
+                    walkZodSchema(option, `${path}[union:${index}]`, issues, toolName)
+                })
+            }
+            break
+        }
+        case 'ZodIntersection':
+            walkZodSchema(schema._def.left, `${path}[left]`, issues, toolName)
+            walkZodSchema(schema._def.right, `${path}[right]`, issues, toolName)
+            break
+
+        case 'ZodRecord':
+            if (schema._def.valueType) {
+                walkZodSchema(schema._def.valueType, `${path}[value]`, issues, toolName)
+            }
+            break
+
+        case 'ZodTuple':
+            if (schema._def.items) {
+                schema._def.items.forEach((item: z.ZodTypeAny, index: number) => {
+                    walkZodSchema(item, `${path}[${index}]`, issues, toolName)
+                })
+            }
+            break
+    }
+}
+
+/**
+ * Validate a single tool's parameter schema
+ */
+// biome-ignore lint/suspicious/noExplicitAny: this is a tooling script
+function validateToolSchema(tool: any): ValidationIssue[] {
+    const issues: ValidationIssue[] = []
+    const toolName = tool.name || 'unknown'
+
+    if (!tool.parameters) {
+        return issues
+    }
+
+    try {
+        const schema = z.object(tool.parameters)
+        walkZodSchema(schema, '', issues, toolName)
+    } catch (error) {
+        issues.push({
+            toolName,
+            parameterPath: 'root',
+            issue: `Failed to analyze schema: ${error}`,
+            suggestion: 'Check that the tool parameters are valid Zod schemas',
+        })
+    }
+
+    return issues
+}
+
+/**
+ * Main validation function using runtime schema analysis
+ */
+async function validateAllSchemas(verbose: boolean = false): Promise<ValidationResult> {
+    try {
+        const { tools } = await import(`${process.cwd()}/dist/index.js`)
+
+        const allIssues: ValidationIssue[] = []
+        let totalParameters = 0
+        const toolNames = Object.keys(tools)
+
+        for (const toolName of toolNames) {
+            const tool = tools[toolName]
+            const toolIssues = validateToolSchema(tool)
+            allIssues.push(...toolIssues)
+
+            // Count parameters for stats
+            if (tool.parameters) {
+                try {
+                    const schema = z.object(tool.parameters)
+                    const shape = schema._def.shape()
+                    totalParameters += Object.keys(shape).length
+                } catch {
+                    // Skip counting if schema is invalid
+                }
+            }
+
+            if (verbose) {
+                const issueCount = toolIssues.length
+                const status = issueCount === 0 ? '✅' : `❌ (${issueCount} issues)`
+                const paramCount = tool.parameters ? Object.keys(tool.parameters).length : 0
+                console.log(`${status} ${toolName} (${paramCount} parameters)`)
+
+                if (issueCount > 0) {
+                    toolIssues.forEach((issue) => {
+                        console.log(`    ${issue.parameterPath}: ${issue.issue}`)
+                    })
+                }
+            }
+        }
+
+        return {
+            success: allIssues.length === 0,
+            issues: allIssues,
+            toolsChecked: toolNames.length,
+            parametersChecked: totalParameters,
+        }
+    } catch (error) {
+        return {
+            success: false,
+            issues: [
+                {
+                    toolName: 'system',
+                    parameterPath: 'import',
+                    issue: `Failed to import tools: ${error}`,
+                    suggestion: 'Ensure the project is built and dist/index.js exists',
+                },
+            ],
+            toolsChecked: 0,
+            parametersChecked: 0,
+        }
+    }
+}
+
+/**
+ * CLI interface
+ */
+async function main() {
+    const args = process.argv.slice(2)
+    const verbose = args.includes('--verbose')
+    const jsonOutput = args.includes('--json')
+
+    try {
+        const result = await validateAllSchemas(verbose)
+
+        if (jsonOutput) {
+            console.log(JSON.stringify(result, null, 2))
+        } else {
+            if (result.success) {
+                console.log('✅ Schema validation passed!')
+                console.log(
+                    `   Checked ${result.toolsChecked} tools with ${result.parametersChecked} parameters`,
+                )
+                console.log(
+                    '   All schemas are Gemini API compatible (no .nullable() on optional strings)',
+                )
+            } else {
+                console.log('❌ Schema validation failed!')
+                console.log(
+                    `   Found ${result.issues.length} issue(s) in ${result.toolsChecked} tools:\n`,
+                )
+
+                result.issues.forEach((issue, index) => {
+                    console.log(`\n${index + 1}. 🚫 VALIDATION FAILURE`)
+                    console.log(`   Tool: ${issue.toolName}`)
+                    console.log(`   Parameter: ${issue.parameterPath}`)
+                    console.log(`   Issue: ${issue.issue}`)
+                    console.log(`   Action Required: ${issue.suggestion}`)
+                    console.log(`   File Location: src/tools/${issue.toolName}.ts`)
+                    console.log(`   Fix Pattern: Remove .nullable() from the parameter schema`)
+                    console.log(
+                        `   Example Fix: Change z.string().nullable().optional() → z.string().optional()`,
+                    )
+                    console.log(
+                        `   ⚠️  This validation failure will cause Gemini API HTTP 400 errors\n`,
+                    )
+                })
+            }
+        }
+
+        process.exit(result.success ? 0 : 1)
+    } catch (error) {
+        console.error('Fatal error during schema validation:', error)
+        process.exit(1)
+    }
+}
+
+// Run if this script is executed directly
+if (process.argv[1]?.endsWith('validate-schemas.js')) {
+    main()
+}
+
+export type { ValidationResult, ValidationIssue }
+export { validateAllSchemas }