@doist/todoist-ai 4.15.1 → 4.16.0

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/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-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/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.1",
+    "version": "4.16.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -46,9 +46,9 @@
         "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.9.0",
         "dotenv": "^17.0.0",
         "zod": "^3.25.7"
     },