@doist/todoist-ai 4.9.2 → 4.9.4

package/dist/index.d.ts

@@ -328,18 +328,20 @@ declare const tools: {
         parameters: {
             labels: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
             labelsOperator: import("zod").ZodOptional<import("zod").ZodEnum<["and", "or"]>>;
-            startDate: import("zod").ZodString;
+            startDate: import("zod").ZodOptional<import("zod").ZodString>;
+            overdueOption: import("zod").ZodOptional<import("zod").ZodEnum<["overdue-only", "include-overdue", "exclude-overdue"]>>;
             daysCount: import("zod").ZodDefault<import("zod").ZodNumber>;
             limit: import("zod").ZodDefault<import("zod").ZodNumber>;
             cursor: import("zod").ZodOptional<import("zod").ZodString>;
         };
         execute(args: {
             limit: number;
-            startDate: string;
             daysCount: number;
             labels?: string[] | undefined;
             cursor?: string | undefined;
             labelsOperator?: "and" | "or" | undefined;
+            startDate?: string | undefined;
+            overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
         }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
             content: {
                 type: "text";
@@ -366,11 +368,12 @@ declare const tools: {
                 hasMore: boolean;
                 appliedFilters: {
                     limit: number;
-                    startDate: string;
                     daysCount: number;
                     labels?: string[] | undefined;
                     cursor?: string | undefined;
                     labelsOperator?: "and" | "or" | undefined;
+                    startDate?: string | undefined;
+                    overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
                 };
             };
         } | {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/mcp-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-helpers.d.ts","sourceRoot":"","sources":["../src/mcp-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,yCAAyC,CAAA;AACtF,OAAO,KAAK,EAAc,CAAC,EAAE,MAAM,KAAK,CAAA;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAkBpD;;;;;;;GAOG;AACH,iBAAS,aAAa,CAAC,iBAAiB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACtE,WAAW,EACX,iBAAiB,GACpB,EAAE;IACC,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,iBAAiB,CAAA;CACvC;;;;;;;;;;;;;;;;;EAeA;AASD;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,EAC9C,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,UAAU,QAqBrB;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA"}
+{"version":3,"file":"mcp-helpers.d.ts","sourceRoot":"","sources":["../src/mcp-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,yCAAyC,CAAA;AACtF,OAAO,KAAK,EAAc,CAAC,EAAE,MAAM,KAAK,CAAA;AACxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAmBpD;;;;;;;GAOG;AACH,iBAAS,aAAa,CAAC,iBAAiB,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACtE,WAAW,EACX,iBAAiB,GACpB,EAAE;IACC,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,iBAAiB,CAAA;CACvC;;;;;;;;;;;;;;;;;EAkBA;AASD;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,MAAM,SAAS,CAAC,CAAC,WAAW,EAC9C,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,EACzB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,UAAU,QAqBrB;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA"}

package/dist/mcp-helpers.js

@@ -1,3 +1,4 @@
+import { removeNullFields } from './utils/sanitize-data.js';
 /**
  * Wether to return the structured content directly, vs. in the `content` part of the output.
  *
@@ -21,13 +22,15 @@ const USE_STRUCTURED_CONTENT = process.env.USE_STRUCTURED_CONTENT === 'true' ||
  * @see USE_STRUCTURED_CONTENT - Wether to use the structured content feature of the MCP protocol.
  */
 function getToolOutput({ textContent, structuredContent, }) {
+    // Remove null fields from structured content before returning
+    const sanitizedContent = removeNullFields(structuredContent);
     if (USE_STRUCTURED_CONTENT) {
         return {
             content: [{ type: 'text', text: textContent }],
-            structuredContent,
+            structuredContent: sanitizedContent,
         };
     }
-    const json = JSON.stringify(structuredContent);
+    const json = JSON.stringify(sanitizedContent);
     return {
         content: [
             { type: 'text', text: textContent },

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

@@ -143,7 +143,11 @@ describe(`${ADD_PROJECTS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                projects: mockProjects,
+                projects: expect.arrayContaining([
+                    expect.objectContaining({ id: 'project-1', name: 'First Project' }),
+                    expect.objectContaining({ id: 'project-2', name: 'Second Project' }),
+                    expect.objectContaining({ id: 'project-3', name: 'Third Project' }),
+                ]),
                 totalCount: 3,
             }));
         });

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

@@ -122,7 +122,11 @@ describe(`${ADD_SECTIONS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                sections: mockSections,
+                sections: expect.arrayContaining([
+                    expect.objectContaining({ id: 'section-1', name: 'First Section' }),
+                    expect.objectContaining({ id: 'section-2', name: 'Second Section' }),
+                    expect.objectContaining({ id: 'section-3', name: 'Third Section' }),
+                ]),
                 totalCount: 3,
             }));
         });

package/dist/tools/__tests__/assignment-integration.test.js

@@ -311,7 +311,7 @@ describe('Assignment Integration Tests', () => {
                 projectId: 'project-123',
             }, mockTodoistApi);
             expect(extractTextContent(result)).toContain('is not shared and has no collaborators');
-            expect(extractStructuredContent(result).collaborators).toHaveLength(0);
+            expect(extractStructuredContent(result).collaborators).toBeUndefined(); // Empty arrays are removed
         });
         it('should handle project not found', async () => {
             mockTodoistApi.getProject.mockRejectedValueOnce(new Error('Project not found'));

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

@@ -24,13 +24,13 @@ describe(`${COMPLETE_TASKS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content
             const { structuredContent } = result;
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 completed: ['task-1', 'task-2', 'task-3'],
-                failures: [],
+                // failures array is removed when empty
                 totalRequested: 3,
                 successCount: 3,
                 failureCount: 0,
-            }));
+            });
         });
         it('should complete single task', async () => {
             mockTodoistApi.closeTask.mockResolvedValue(true);
@@ -40,13 +40,13 @@ describe(`${COMPLETE_TASKS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content
             const { structuredContent } = result;
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 completed: ['8485093748'],
-                failures: [],
+                // failures array is removed when empty
                 totalRequested: 1,
                 successCount: 1,
                 failureCount: 0,
-            }));
+            });
         });
         it('should handle partial failures gracefully', async () => {
             // Mock first and third tasks to succeed, second to fail

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

@@ -55,7 +55,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'task',
                 searchId: 'task123',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 2,
             }));
         });
@@ -128,7 +127,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'project',
                 searchId: 'project456',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -155,13 +153,11 @@ describe(`${FIND_COMMENTS} tool`, () => {
                         id: 'comment789',
                         content: 'Single comment content',
                         taskId: 'task123',
-                        fileAttachment: null,
                     }),
                 ]),
                 searchType: 'single',
                 searchId: 'comment789',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -200,7 +196,6 @@ describe(`${FIND_COMMENTS} tool`, () => {
                 searchType: 'single',
                 searchId: 'comment789',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 1,
             }));
         });
@@ -229,14 +224,13 @@ describe(`${FIND_COMMENTS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                comments: [],
+            expect(structuredContent).toEqual({
                 searchType: 'task',
                 searchId: 'task123',
                 hasMore: false,
-                nextCursor: null,
                 totalCount: 0,
-            }));
+                // comments array is removed when empty
+            });
         });
     });
 });

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

@@ -53,7 +53,6 @@ describe(`${FIND_PROJECTS} tool`, () => {
                 projects: expect.any(Array),
                 totalCount: 3,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: {
                     search: undefined,
                     limit: 50,
@@ -112,7 +111,6 @@ describe(`${FIND_PROJECTS} tool`, () => {
             expect(structuredContent.projects).toHaveLength(2); // Should match filtered results
             expect(structuredContent.totalCount).toBe(2);
             expect(structuredContent.hasMore).toBe(false);
-            expect(structuredContent.nextCursor).toBeNull();
             expect(structuredContent.appliedFilters).toEqual({
                 search: 'work',
                 limit: 50,

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

@@ -77,12 +77,8 @@ describe(`${FIND_SECTIONS} tool`, () => {
             expect(textContent).toContain(`Use ${ADD_SECTIONS} to create sections`);
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent.sections).toHaveLength(0);
+            expect(structuredContent.sections).toBeUndefined(); // Empty arrays are removed
             expect(structuredContent.totalCount).toBe(0);
-            expect(structuredContent.appliedFilters).toEqual({
-                projectId: 'empty-project-id',
-                search: undefined,
-            });
         });
     });
     describe('searching sections by name', () => {

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

@@ -20,18 +20,19 @@ const mockTodoistApi = {
 const mockTodoistUser = createMockUser();
 // Mock date-fns functions to make tests deterministic
 jest.mock('date-fns', () => ({
-    addDays: jest.fn(() => new Date('2025-08-16')), // Return predictable end date
+    addDays: jest.fn((date, amount) => {
+        const d = new Date(date);
+        d.setDate(d.getDate() + amount);
+        return d;
+    }),
     formatISO: jest.fn((date, options) => {
         if (typeof date === 'string') {
             return date; // Return string dates as-is
         }
-        if (options &&
-            typeof options === 'object' &&
-            'representation' in options &&
-            options.representation === 'date') {
-            return '2025-08-15'; // Return predictable date for 'today'
+        if (options?.representation === 'date') {
+            return date.toISOString().split('T')[0];
         }
-        return '2025-08-16'; // Return predictable end date
+        return date.toISOString();
     }),
 }));
 const { FIND_TASKS_BY_DATE, UPDATE_TASKS } = ToolNames;
@@ -46,6 +47,23 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
         jest.restoreAllMocks();
     });
     describe('listing tasks by date range', () => {
+        it('only returns tasks for the startDate when daysCount is 1', async () => {
+            const mockTasks = [
+                createMappedTask({ content: 'Task for specific date', dueDate: '2025-08-20' }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: '2025-08-20', limit: 50, daysCount: 1 }, mockTodoistApi);
+            // Verify the query uses daysCount=1 by checking the end date calculation
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: '(due after: 2025-08-20 | due: 2025-08-20) & due before: 2025-08-21',
+                cursor: undefined,
+                limit: 50,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toMatchSnapshot();
+        });
         it('should get tasks for today when startDate is "today" (includes overdue)', async () => {
             const mockTasks = [createMappedTask({ content: 'Today task', dueDate: '2025-08-15' })];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
@@ -375,7 +393,7 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             ];
             const mockResponse = { tasks: mockTasks, nextCursor: null };
             mockGetTasksByFilter.mockResolvedValue(mockResponse);
-            const result = await findTasksByDate.execute({ startDate: 'overdue', daysCount: 1, limit: 50 }, mockTodoistApi);
+            const result = await findTasksByDate.execute({ overdueOption: 'overdue-only', daysCount: 1, limit: 50 }, mockTodoistApi);
             const structuredContent = extractStructuredContent(result);
             // Should only return tasks 1 and 2, not task 3
             expect(structuredContent.tasks).toHaveLength(2);

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

@@ -117,7 +117,6 @@ describe(`${FIND_TASKS} tool`, () => {
                 tasks: expect.any(Array),
                 totalCount: 1,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: expect.objectContaining({
                     searchText: params.searchText,
                     limit: expectedLimit,
@@ -144,15 +143,14 @@ describe(`${FIND_TASKS} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Verify structured content for empty results
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
-                tasks: [],
+            expect(structuredContent).toEqual({
+                // tasks array is removed when empty
                 totalCount: 0,
                 hasMore: false,
-                nextCursor: null,
                 appliedFilters: expect.objectContaining({
                     searchText: searchText,
                 }),
-            }));
+            });
         });
     });
     describe('validation', () => {

package/dist/tools/__tests__/get-overview.test.js

@@ -59,7 +59,7 @@ describe(`${GET_OVERVIEW} tool`, () => {
                 inbox: expect.objectContaining({
                     id: TEST_IDS.PROJECT_INBOX,
                     name: 'Inbox',
-                    sections: expect.any(Array),
+                    // sections array removed if empty
                 }),
                 projects: expect.any(Array),
                 totalProjects: 2,
@@ -75,14 +75,13 @@ describe(`${GET_OVERVIEW} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Test structured content sanity checks
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 type: 'account_overview',
-                inbox: null,
-                projects: [],
+                // projects array is removed when empty
                 totalProjects: 0,
                 totalSections: 0,
                 hasNestedProjects: false,
-            }));
+            });
         });
     });
     describe('project overview (with projectId)', () => {
@@ -188,20 +187,19 @@ describe(`${GET_OVERVIEW} tool`, () => {
             expect(extractTextContent(result)).toMatchSnapshot();
             // Test structured content sanity checks
             const structuredContent = extractStructuredContent(result);
-            expect(structuredContent).toEqual(expect.objectContaining({
+            expect(structuredContent).toEqual({
                 type: 'project_overview',
                 project: expect.objectContaining({
                     id: 'empty-project-id',
                     name: 'Empty Project',
                 }),
-                sections: [],
-                tasks: [],
+                // sections and tasks arrays are removed when empty
                 stats: expect.objectContaining({
                     totalTasks: 0,
                     totalSections: 0,
                     tasksWithoutSection: 0,
                 }),
-            }));
+            });
         });
     });
     describe('error handling', () => {

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

@@ -52,7 +52,6 @@ describe(`${UPDATE_COMMENTS} tool`, () => {
                     id: '98765',
                     content: 'Updated content here',
                     taskId: 'task456',
-                    fileAttachment: null,
                 }),
             ],
             totalCount: 1,
@@ -89,7 +88,6 @@ describe(`${UPDATE_COMMENTS} tool`, () => {
                     content: 'Updated project comment',
                     taskId: undefined,
                     projectId: 'project789',
-                    fileAttachment: null,
                 }),
             ],
             totalCount: 1,

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

@@ -47,7 +47,12 @@ describe(`${UPDATE_PROJECTS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                projects: [mockApiResponse],
+                projects: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: 'existing-project-123',
+                        name: 'Updated Project Name',
+                    }),
+                ]),
                 totalCount: 1,
                 updatedProjectIds: ['existing-project-123'],
                 appliedOperations: {
@@ -140,7 +145,14 @@ describe(`${UPDATE_PROJECTS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                projects: mockProjects,
+                projects: expect.arrayContaining([
+                    expect.objectContaining({ id: 'project-1', name: 'Updated First Project' }),
+                    expect.objectContaining({
+                        id: 'project-2',
+                        name: 'Updated Second Project',
+                    }),
+                    expect.objectContaining({ id: 'project-3', name: 'Updated Third Project' }),
+                ]),
                 totalCount: 3,
                 updatedProjectIds: ['project-1', 'project-2', 'project-3'],
                 appliedOperations: {

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

@@ -40,7 +40,12 @@ describe(`${UPDATE_SECTIONS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                sections: [mockApiResponse],
+                sections: expect.arrayContaining([
+                    expect.objectContaining({
+                        id: 'existing-section-123',
+                        name: 'Updated Section Name',
+                    }),
+                ]),
                 totalCount: 1,
                 updatedSectionIds: ['existing-section-123'],
             }));
@@ -97,7 +102,14 @@ describe(`${UPDATE_SECTIONS} tool`, () => {
             // Verify structured content
             const structuredContent = extractStructuredContent(result);
             expect(structuredContent).toEqual(expect.objectContaining({
-                sections: mockSections,
+                sections: expect.arrayContaining([
+                    expect.objectContaining({ id: 'section-1', name: 'Updated First Section' }),
+                    expect.objectContaining({
+                        id: 'section-2',
+                        name: 'Updated Second Section',
+                    }),
+                    expect.objectContaining({ id: 'section-3', name: 'Updated Third Section' }),
+                ]),
                 totalCount: 3,
                 updatedSectionIds: ['section-1', 'section-2', 'section-3'],
             }));

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

@@ -673,7 +673,7 @@ describe(`${UPDATE_TASKS} tool`, () => {
                 const textContent = extractTextContent(result);
                 expect(textContent).toContain('Updated 0 tasks');
                 const structuredContent = extractStructuredContent(result);
-                expect(structuredContent.tasks).toHaveLength(0);
+                expect(structuredContent.tasks).toBeUndefined(); // Empty arrays are removed
                 expect(structuredContent.totalCount).toBe(0);
             });
         });

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

@@ -5,18 +5,20 @@ declare const findTasksByDate: {
     parameters: {
         labels: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         labelsOperator: z.ZodOptional<z.ZodEnum<["and", "or"]>>;
-        startDate: z.ZodString;
+        startDate: z.ZodOptional<z.ZodString>;
+        overdueOption: z.ZodOptional<z.ZodEnum<["overdue-only", "include-overdue", "exclude-overdue"]>>;
         daysCount: z.ZodDefault<z.ZodNumber>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         limit: number;
-        startDate: string;
         daysCount: number;
         labels?: string[] | undefined;
         cursor?: string | undefined;
         labelsOperator?: "and" | "or" | undefined;
+        startDate?: string | undefined;
+        overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -43,11 +45,12 @@ declare const findTasksByDate: {
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                startDate: string;
                 daysCount: number;
                 labels?: string[] | undefined;
                 cursor?: string | undefined;
                 labelsOperator?: "and" | "or" | undefined;
+                startDate?: string | undefined;
+                overdueOption?: "overdue-only" | "include-overdue" | "exclude-overdue" | undefined;
             };
         };
     } | {

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;AA0CvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0DqB,CAAA;AAoE1C,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;AAmDvB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEqB,CAAA;AAwF1C,OAAO,EAAE,eAAe,EAAE,CAAA"}

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

@@ -10,14 +10,19 @@ const ArgsSchema = {
     startDate: z
         .string()
         .regex(/^(\d{4}-\d{2}-\d{2}|today)$/)
+        .optional()
         .describe("The start date to get the tasks for. Format: YYYY-MM-DD or 'today'."),
+    overdueOption: z
+        .enum(['overdue-only', 'include-overdue', 'exclude-overdue'])
+        .optional()
+        .describe("How to handle overdue tasks. 'overdue-only' to get only overdue tasks, 'include-overdue' to include overdue tasks along with tasks for the specified date(s), and 'exclude-overdue' to exclude overdue tasks. Default is 'include-overdue'."),
     daysCount: z
         .number()
         .int()
         .min(1)
         .max(30)
         .default(1)
-        .describe('The number of days to get the tasks for, starting from the start date.'),
+        .describe('The number of days to get the tasks for, starting from the start date. Default is 1 which means only tasks for the start date.'),
     limit: z
         .number()
         .int()
@@ -36,14 +41,22 @@ const findTasksByDate = {
     description: "Get tasks by date range. Use startDate 'today' to get today's tasks including overdue items, or provide a specific date/date range.",
     parameters: ArgsSchema,
     async execute(args, client) {
+        if (!args.startDate && args.overdueOption !== 'overdue-only') {
+            throw new Error('Either startDate must be provided or overdueOption must be set to overdue-only');
+        }
         let query = '';
         const todoistUser = await client.getUser();
-        if (args.startDate === 'today') {
-            query = 'today | overdue';
+        if (args.overdueOption === 'overdue-only') {
+            query = 'overdue';
         }
-        else {
+        else if (args.startDate === 'today') {
+            // For 'today', include overdue unless explicitly excluded
+            query = args.overdueOption === 'exclude-overdue' ? 'today' : 'today | overdue';
+        }
+        else if (args.startDate) {
+            // For specific dates, never include overdue tasks
             const startDate = args.startDate;
-            const endDate = addDays(startDate, args.daysCount + 1);
+            const endDate = addDays(startDate, args.daysCount);
             const endDateStr = formatISO(endDate, { representation: 'date' });
             query = `(due after: ${startDate} | due: ${startDate}) & due before: ${endDateStr}`;
         }
@@ -87,11 +100,18 @@ const findTasksByDate = {
 function generateTextContent({ tasks, args, nextCursor, }) {
     // Generate filter description
     const filterHints = [];
-    if (args.startDate === 'today') {
-        filterHints.push(`today + overdue tasks${args.daysCount > 1 ? ` + ${args.daysCount - 1} more days` : ''}`);
+    if (args.overdueOption === 'overdue-only') {
+        filterHints.push('overdue tasks only');
     }
-    else {
-        filterHints.push(`${args.startDate}${args.daysCount > 1 ? ` to ${getDateString(addDays(args.startDate, args.daysCount))}` : ''}`);
+    else if (args.startDate === 'today') {
+        const overdueText = args.overdueOption === 'exclude-overdue' ? '' : ' + overdue tasks';
+        filterHints.push(`today${overdueText}${args.daysCount > 1 ? ` + ${args.daysCount - 1} more days` : ''}`);
+    }
+    else if (args.startDate) {
+        const dateRange = args.daysCount > 1
+            ? ` to ${getDateString(addDays(args.startDate, args.daysCount))}`
+            : '';
+        filterHints.push(`${args.startDate}${dateRange}`);
     }
     // Add label filter information
     if (args.labels && args.labels.length > 0) {
@@ -101,12 +121,29 @@ function generateTextContent({ tasks, args, nextCursor, }) {
         filterHints.push(`labels: ${labelText}`);
     }
     // Generate subject description
-    const subject = args.startDate === 'today' ? `Today's tasks + overdue` : `Tasks for ${args.startDate}`;
+    let subject = '';
+    if (args.overdueOption === 'overdue-only') {
+        subject = 'Overdue tasks';
+    }
+    else if (args.startDate === 'today') {
+        subject =
+            args.overdueOption === 'exclude-overdue' ? `Today's tasks` : `Today's tasks + overdue`;
+    }
+    else if (args.startDate) {
+        subject = `Tasks for ${args.startDate}`;
+    }
+    else {
+        subject = 'Tasks';
+    }
     // Generate helpful suggestions for empty results
     const zeroReasonHints = [];
     if (tasks.length === 0) {
-        if (args.startDate === 'today') {
-            zeroReasonHints.push('Great job! No tasks for today or overdue');
+        if (args.overdueOption === 'overdue-only') {
+            zeroReasonHints.push('Great job! No overdue tasks');
+        }
+        else if (args.startDate === 'today') {
+            const overdueNote = args.overdueOption === 'exclude-overdue' ? '' : ' or overdue';
+            zeroReasonHints.push(`Great job! No tasks for today${overdueNote}`);
         }
         else {
             zeroReasonHints.push("Expand date range with larger 'daysCount'");
@@ -116,10 +153,12 @@ function generateTextContent({ tasks, args, nextCursor, }) {
     // Generate contextual next steps
     const now = new Date();
     const todayStr = getDateString(now);
+    const hasOverdue = args.overdueOption === 'overdue-only' ||
+        args.startDate === 'today' ||
+        tasks.some((task) => task.dueDate && new Date(task.dueDate) < now);
     const nextSteps = generateTaskNextSteps('listed', tasks, {
         hasToday: args.startDate === 'today' || tasks.some((task) => task.dueDate === todayStr),
-        hasOverdue: args.startDate === 'today' ||
-            tasks.some((task) => task.dueDate && new Date(task.dueDate) < now),
+        hasOverdue,
     });
     return summarizeList({
         subject,

package/dist/utils/sanitize-data.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Removes all null fields, empty objects, and empty arrays from an object recursively.
+ * This ensures that data sent to agents doesn't include unnecessary empty values.
+ *
+ * @param obj - The object to sanitize
+ * @returns A new object with all null fields, empty objects, and empty arrays removed
+ */
+export declare function removeNullFields<T>(obj: T): T;
+//# sourceMappingURL=sanitize-data.d.ts.map

package/dist/utils/sanitize-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-data.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize-data.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAqC7C"}

package/dist/utils/sanitize-data.js

@@ -0,0 +1,37 @@
+/**
+ * Removes all null fields, empty objects, and empty arrays from an object recursively.
+ * This ensures that data sent to agents doesn't include unnecessary empty values.
+ *
+ * @param obj - The object to sanitize
+ * @returns A new object with all null fields, empty objects, and empty arrays removed
+ */
+export function removeNullFields(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => removeNullFields(item));
+    }
+    if (typeof obj === 'object') {
+        const sanitized = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value !== null) {
+                const cleanedValue = removeNullFields(value);
+                // Skip empty arrays
+                if (Array.isArray(cleanedValue) && cleanedValue.length === 0) {
+                    continue;
+                }
+                // Skip empty objects
+                if (cleanedValue !== null &&
+                    typeof cleanedValue === 'object' &&
+                    !Array.isArray(cleanedValue) &&
+                    Object.keys(cleanedValue).length === 0) {
+                    continue;
+                }
+                sanitized[key] = cleanedValue;
+            }
+        }
+        return sanitized;
+    }
+    return obj;
+}

package/dist/utils/sanitize-data.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sanitize-data.test.d.ts.map

package/dist/utils/sanitize-data.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize-data.test.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize-data.test.ts"],"names":[],"mappings":""}

package/dist/utils/sanitize-data.test.js

@@ -0,0 +1,93 @@
+import { removeNullFields } from './sanitize-data.js';
+describe('removeNullFields', () => {
+    it('should remove null fields from objects including nested objects', () => {
+        const input = {
+            name: 'John',
+            age: null,
+            email: 'john@example.com',
+            phone: null,
+            address: {
+                street: '123 Main St',
+                city: null,
+                country: 'USA',
+            },
+        };
+        const result = removeNullFields(input);
+        expect(result).toEqual({
+            name: 'John',
+            email: 'john@example.com',
+            address: {
+                street: '123 Main St',
+                country: 'USA',
+            },
+        });
+    });
+    it('should handle arrays with null values', () => {
+        const input = {
+            items: [
+                { id: 1, value: 'test' },
+                { id: 2, value: null },
+                { id: 3, value: 'another' },
+            ],
+        };
+        const result = removeNullFields(input);
+        expect(result).toEqual({
+            items: [{ id: 1, value: 'test' }, { id: 2 }, { id: 3, value: 'another' }],
+        });
+    });
+    it('should handle null objects', () => {
+        const result = removeNullFields(null);
+        expect(result).toBeNull();
+    });
+    it('should remove empty objects and empty arrays', () => {
+        const input = {
+            something: 'hello',
+            another: {},
+            yetAnother: [],
+        };
+        const result = removeNullFields(input);
+        expect(result).toEqual({
+            something: 'hello',
+        });
+    });
+    it('should remove empty objects and empty arrays in nested structures', () => {
+        const input = {
+            name: 'Test',
+            metadata: {},
+            tags: [],
+            nested: {
+                data: 'value',
+                emptyObj: {},
+                emptyArr: [],
+                deepNested: {
+                    anotherEmpty: {},
+                },
+            },
+            items: [
+                { id: 1, data: 'test', empty: {} },
+                { id: 2, list: [] },
+            ],
+        };
+        const result = removeNullFields(input);
+        expect(result).toEqual({
+            name: 'Test',
+            nested: {
+                data: 'value',
+            },
+            items: [{ id: 1, data: 'test' }, { id: 2 }],
+        });
+    });
+    it('should keep arrays with values and objects with properties', () => {
+        const input = {
+            emptyArray: [],
+            arrayWithValues: [1, 2, 3],
+            emptyObject: {},
+            objectWithProps: { key: 'value' },
+        };
+        const result = removeNullFields(input);
+        expect(result).toEqual({
+            arrayWithValues: [1, 2, 3],
+            objectWithProps: { key: 'value' },
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "4.9.2",
+    "version": "4.9.4",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
@@ -52,7 +52,7 @@
         "zod": "^3.25.7"
     },
     "devDependencies": {
-        "@biomejs/biome": "2.2.4",
+        "@biomejs/biome": "2.2.5",
         "@types/express": "^5.0.2",
         "@types/jest": "30.0.0",
         "@types/morgan": "^1.9.9",