@doist/todoist-ai 2.0.1 → 2.1.0

package/dist/index.d.ts

@@ -136,6 +136,7 @@ declare const tools: {
                 sectionId: string | null;
                 parentId: string | null;
                 labels: string[];
+                duration: string | null;
             }[];
             nextCursor: string | null;
         }>;
@@ -176,6 +177,7 @@ declare const tools: {
                 sectionId: string | null;
                 parentId: string | null;
                 labels: string[];
+                duration: string | null;
             }[];
             nextCursor: string | null;
         }>;
@@ -206,6 +208,7 @@ declare const tools: {
                 sectionId: string | null;
                 parentId: string | null;
                 labels: string[];
+                duration: string | null;
             }[];
             nextCursor: string | null;
         }>;
@@ -247,6 +250,7 @@ declare const tools: {
                 sectionId: string | null;
                 parentId: string | null;
                 labels: string[];
+                duration: string | null;
             }[];
             nextCursor: string | null;
         }>;
@@ -263,16 +267,19 @@ declare const tools: {
                 description: import("zod").ZodOptional<import("zod").ZodString>;
                 priority: import("zod").ZodOptional<import("zod").ZodNumber>;
                 dueString: import("zod").ZodOptional<import("zod").ZodString>;
+                duration: import("zod").ZodOptional<import("zod").ZodString>;
             }, "strip", import("zod").ZodTypeAny, {
                 content: string;
                 description?: string | undefined;
                 priority?: number | undefined;
                 dueString?: string | undefined;
+                duration?: string | undefined;
             }, {
                 content: string;
                 description?: string | undefined;
                 priority?: number | undefined;
                 dueString?: string | undefined;
+                duration?: string | undefined;
             }>, "many">;
         };
         execute(args: {
@@ -281,6 +288,7 @@ declare const tools: {
                 description?: string | undefined;
                 priority?: number | undefined;
                 dueString?: string | undefined;
+                duration?: string | undefined;
             }[];
             parentId?: string | undefined;
             projectId?: string | undefined;
@@ -296,6 +304,7 @@ declare const tools: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[]>;
     };
     tasksUpdateOne: {
@@ -310,6 +319,7 @@ declare const tools: {
             parentId: import("zod").ZodOptional<import("zod").ZodString>;
             priority: import("zod").ZodOptional<import("zod").ZodNumber>;
             dueString: import("zod").ZodOptional<import("zod").ZodString>;
+            duration: import("zod").ZodOptional<import("zod").ZodString>;
         };
         execute(args: {
             id: string;
@@ -320,6 +330,7 @@ declare const tools: {
             sectionId?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").Task | undefined>;
     };
     tasksOrganizeMultiple: {

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,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAA;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAE5D,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeV,CAAA;AAED,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAA;AAE9B,OAAO,EACH,YAAY,EACZ,cAAc,EACd,SAAS,EACT,cAAc,EACd,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,QAAQ,GACX,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAE9C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAE3D,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAChE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAA;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAA;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAA;AAE5D,QAAA,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAeV,CAAA;AAED,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAA;AAE9B,OAAO,EACH,YAAY,EACZ,cAAc,EACd,SAAS,EACT,cAAc,EACd,cAAc,EACd,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,QAAQ,GACX,CAAA"}

package/dist/tool-helpers.d.ts

@@ -28,6 +28,7 @@ declare function mapTask(task: Task): {
     sectionId: string | null;
     parentId: string | null;
     labels: string[];
+    duration: string | null;
 };
 /**
  * Map a single Todoist project to a more structured format, for LLM consumption.
@@ -61,6 +62,7 @@ declare function getTasksByFilter({ client, query, limit, cursor, }: {
         sectionId: string | null;
         parentId: string | null;
         labels: string[];
+        duration: string | null;
     }[];
     nextCursor: string | null;
 }>;

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

@@ -1 +1 @@
-{"version":3,"file":"tool-helpers.d.ts","sourceRoot":"","sources":["../src/tool-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,gBAAgB,EAExB,MAAM,+BAA+B,CAAA;AAGtC,MAAM,MAAM,OAAO,GAAG,eAAe,GAAG,gBAAgB,CAAA;AAExD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,eAAe,CAE9E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,GAClB,YAAY,CAsBd;AAED;;;;GAIG;AACH,iBAAS,OAAO,CAAC,IAAI,EAAE,IAAI;;;;;;;;;;;EAa1B;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,OAAO,EAAE,OAAO;;;;;;;;;EAWnC;AAWD,iBAAe,gBAAgB,CAAC,EAC5B,MAAM,EACN,KAAK,EACL,KAAK,EACL,MAAM,GACT,EAAE;IACC,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B;;;;;;;;;;;;;;GAyBA;AAED,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"tool-helpers.d.ts","sourceRoot":"","sources":["../src/tool-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,gBAAgB,EAExB,MAAM,+BAA+B,CAAA;AAItC,MAAM,MAAM,OAAO,GAAG,eAAe,GAAG,gBAAgB,CAAA;AAExD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,eAAe,CAE9E;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,gBAAgB,CAEhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,GAClB,YAAY,CAsBd;AAED;;;;GAIG;AACH,iBAAS,OAAO,CAAC,IAAI,EAAE,IAAI;;;;;;;;;;;;EAc1B;AAED;;;;GAIG;AACH,iBAAS,UAAU,CAAC,OAAO,EAAE,OAAO;;;;;;;;;EAWnC;AAWD,iBAAe,gBAAgB,CAAC,EAC5B,MAAM,EACN,KAAK,EACL,KAAK,EACL,MAAM,GACT,EAAE;IACC,MAAM,EAAE,UAAU,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAC7B;;;;;;;;;;;;;;;GAyBA;AAED,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/tool-helpers.js

@@ -1,5 +1,6 @@
 import { getSanitizedContent, } from '@doist/todoist-api-typescript';
 import z from 'zod';
+import { formatDuration } from './utils/duration-parser.js';
 export function isPersonalProject(project) {
     return 'inboxProject' in project;
 }
@@ -51,6 +52,7 @@ function mapTask(task) {
         sectionId: task.sectionId,
         parentId: task.parentId,
         labels: task.labels,
+        duration: task.duration ? formatDuration(task.duration.amount) : null,
     };
 }
 /**

package/dist/tool-helpers.test.js

@@ -30,6 +30,7 @@ describe('shared utilities', () => {
                 sectionId: null,
                 parentId: null,
                 labels: ['work'],
+                duration: null,
             });
         });
         it('should handle recurring tasks', () => {
@@ -52,6 +53,25 @@ describe('shared utilities', () => {
             };
             const result = mapTask(mockTask);
             expect(result.recurring).toBe('every day');
+            expect(result.duration).toBe(null);
+        });
+        it('should handle task with duration', () => {
+            const mockTask = {
+                id: '789',
+                content: 'Task with duration',
+                description: '',
+                projectId: 'proj-1',
+                sectionId: null,
+                parentId: null,
+                labels: [],
+                priority: 1,
+                duration: {
+                    amount: 150,
+                    unit: 'minute',
+                },
+            };
+            const result = mapTask(mockTask);
+            expect(result.duration).toBe('2h30m');
         });
     });
     describe('mapProject', () => {

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

@@ -129,8 +129,122 @@ describe('tasks-add-multiple tool', () => {
                 }),
             ]);
         });
+        it('should add tasks with duration', async () => {
+            const mockApiResponse1 = createMockTask({
+                id: '8485093752',
+                content: 'Task with 2 hour duration',
+                duration: { amount: 120, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093752',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            const mockApiResponse2 = createMockTask({
+                id: '8485093753',
+                content: 'Task with 45 minute duration',
+                duration: { amount: 45, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093753',
+                addedAt: '2025-08-13T22:09:57.123456Z',
+            });
+            mockTodoistApi.addTask
+                .mockResolvedValueOnce(mockApiResponse1)
+                .mockResolvedValueOnce(mockApiResponse2);
+            const result = await tasksAddMultiple.execute({
+                projectId: '6cfCcrrCFg2xP94Q',
+                tasks: [
+                    {
+                        content: 'Task with 2 hour duration',
+                        duration: '2h',
+                    },
+                    {
+                        content: 'Task with 45 minute duration',
+                        duration: '45m',
+                    },
+                ],
+            }, mockTodoistApi);
+            // Verify API was called with parsed duration
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(1, {
+                content: 'Task with 2 hour duration',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+                duration: 120,
+                durationUnit: 'minute',
+            });
+            expect(mockTodoistApi.addTask).toHaveBeenNthCalledWith(2, {
+                content: 'Task with 45 minute duration',
+                projectId: '6cfCcrrCFg2xP94Q',
+                sectionId: undefined,
+                parentId: undefined,
+                duration: 45,
+                durationUnit: 'minute',
+            });
+            // Verify result includes formatted duration
+            expect(result).toEqual([
+                expect.objectContaining({
+                    id: '8485093752',
+                    content: 'Task with 2 hour duration',
+                    duration: '2h',
+                }),
+                expect.objectContaining({
+                    id: '8485093753',
+                    content: 'Task with 45 minute duration',
+                    duration: '45m',
+                }),
+            ]);
+        });
+        it('should handle various duration formats', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093754',
+                content: 'Task with combined duration',
+                duration: { amount: 150, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093754',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            // Test different duration formats
+            const testCases = [
+                { input: '2h30m', expectedMinutes: 150 },
+                { input: '1.5h', expectedMinutes: 90 },
+                { input: ' 90m ', expectedMinutes: 90 },
+                { input: '2H30M', expectedMinutes: 150 },
+            ];
+            for (const testCase of testCases) {
+                mockTodoistApi.addTask.mockClear();
+                await tasksAddMultiple.execute({
+                    tasks: [
+                        {
+                            content: 'Test task',
+                            duration: testCase.input,
+                        },
+                    ],
+                }, mockTodoistApi);
+                expect(mockTodoistApi.addTask).toHaveBeenCalledWith(expect.objectContaining({
+                    duration: testCase.expectedMinutes,
+                    durationUnit: 'minute',
+                }));
+            }
+        });
     });
     describe('error handling', () => {
+        it('should throw error for invalid duration format', async () => {
+            await expect(tasksAddMultiple.execute({
+                tasks: [
+                    {
+                        content: 'Task with invalid duration',
+                        duration: 'invalid',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with invalid duration": Invalid duration format "invalid"');
+        });
+        it('should throw error for duration exceeding 24 hours', async () => {
+            await expect(tasksAddMultiple.execute({
+                tasks: [
+                    {
+                        content: 'Task with too long duration',
+                        duration: '25h',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with too long duration": Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
+        });
         it('should propagate API errors', async () => {
             const apiError = new Error('API Error: Task content is required');
             mockTodoistApi.addTask.mockRejectedValue(apiError);

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

@@ -135,8 +135,98 @@ describe('tasks-update-one tool', () => {
             });
             expect(result).toEqual(updatedTask);
         });
+        it('should update task duration', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093753',
+                content: 'Task with updated duration',
+                duration: { amount: 150, unit: 'minute' },
+                url: 'https://todoist.com/showTask?id=8485093753',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093753',
+                duration: '2h30m',
+            }, mockTodoistApi);
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093753', {
+                duration: 150,
+                durationUnit: 'minute',
+            });
+            expect(result).toEqual(mockApiResponse);
+        });
+        it('should handle various duration formats', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093754',
+                content: 'Test task',
+                duration: { amount: 120, unit: 'minute' },
+            });
+            mockTodoistApi.updateTask.mockResolvedValue(mockApiResponse);
+            // Test different duration formats
+            const testCases = [
+                { input: '2h', expectedMinutes: 120 },
+                { input: '90m', expectedMinutes: 90 },
+                { input: '1.5h', expectedMinutes: 90 },
+                { input: ' 2h 30m ', expectedMinutes: 150 },
+                { input: '2H30M', expectedMinutes: 150 },
+            ];
+            for (const testCase of testCases) {
+                mockTodoistApi.updateTask.mockClear();
+                await tasksUpdateOne.execute({
+                    id: '8485093754',
+                    duration: testCase.input,
+                }, mockTodoistApi);
+                expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093754', expect.objectContaining({
+                    duration: testCase.expectedMinutes,
+                    durationUnit: 'minute',
+                }));
+            }
+        });
+        it('should update task with duration and move at once', async () => {
+            const movedTask = createMockTask({
+                id: '8485093755',
+                content: 'Task to move and update',
+                projectId: 'new-project-id',
+            });
+            const updatedTask = createMockTask({
+                id: '8485093755',
+                content: 'Updated task with duration',
+                duration: { amount: 120, unit: 'minute' },
+                projectId: 'new-project-id',
+            });
+            mockTodoistApi.moveTasks.mockResolvedValue([movedTask]);
+            mockTodoistApi.updateTask.mockResolvedValue(updatedTask);
+            const result = await tasksUpdateOne.execute({
+                id: '8485093755',
+                content: 'Updated task with duration',
+                duration: '2h',
+                projectId: 'new-project-id',
+            }, mockTodoistApi);
+            // Should call moveTasks first
+            expect(mockTodoistApi.moveTasks).toHaveBeenCalledWith(['8485093755'], {
+                projectId: 'new-project-id',
+            });
+            // Then call updateTask with duration
+            expect(mockTodoistApi.updateTask).toHaveBeenCalledWith('8485093755', {
+                content: 'Updated task with duration',
+                duration: 120,
+                durationUnit: 'minute',
+            });
+            expect(result).toEqual(updatedTask);
+        });
     });
     describe('error handling', () => {
+        it('should throw error for invalid duration format', async () => {
+            await expect(tasksUpdateOne.execute({
+                id: '8485093756',
+                duration: 'invalid',
+            }, mockTodoistApi)).rejects.toThrow('Task 8485093756: Invalid duration format "invalid"');
+        });
+        it('should throw error for duration exceeding 24 hours', async () => {
+            await expect(tasksUpdateOne.execute({
+                id: '8485093757',
+                duration: '25h',
+            }, mockTodoistApi)).rejects.toThrow('Task 8485093757: Invalid duration format "25h": Duration cannot exceed 24 hours (1440 minutes)');
+        });
         it('should throw error when multiple move parameters are provided', async () => {
             await expect(tasksUpdateOne.execute({ id: '8485093748', projectId: 'new-project', sectionId: 'new-section' }, mockTodoistApi)).rejects.toThrow('Only one of projectId, sectionId, or parentId can be specified at a time. ' +
                 'The Todoist API requires exactly one destination for move operations.');

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

@@ -11,16 +11,19 @@ declare const tasksAddMultiple: {
             description: z.ZodOptional<z.ZodString>;
             priority: z.ZodOptional<z.ZodNumber>;
             dueString: z.ZodOptional<z.ZodString>;
+            duration: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             content: string;
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }, {
             content: string;
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }>, "many">;
     };
     execute(args: {
@@ -29,6 +32,7 @@ declare const tasksAddMultiple: {
             description?: string | undefined;
             priority?: number | undefined;
             dueString?: string | undefined;
+            duration?: string | undefined;
         }[];
         parentId?: string | undefined;
         projectId?: string | undefined;
@@ -44,6 +48,7 @@ declare const tasksAddMultiple: {
         sectionId: string | null;
         parentId: string | null;
         labels: string[];
+        duration: string | null;
     }[]>;
 };
 export { tasksAddMultiple };

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAaoB,CAAA;AAE1C,OAAO,EAAE,gBAAgB,EAAE,CAAA"}
+{"version":3,"file":"tasks-add-multiple.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-add-multiple.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAyBvB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCoB,CAAA;AAE1C,OAAO,EAAE,gBAAgB,EAAE,CAAA"}

package/dist/tools/tasks-add-multiple.js

@@ -1,10 +1,15 @@
 import { z } from 'zod';
 import { mapTask } from '../tool-helpers.js';
+import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
 const TaskSchema = z.object({
     content: z.string().min(1).describe('The content of the task to create.'),
     description: z.string().optional().describe('The description of the task.'),
     priority: z.number().int().min(1).max(4).optional().describe('The priority of the task (1-4).'),
     dueString: z.string().optional().describe('The due date for the task, in natural language.'),
+    duration: z
+        .string()
+        .optional()
+        .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
 });
 const ArgsSchema = {
     projectId: z.string().optional().describe('The project ID to add the tasks to.'),
@@ -20,7 +25,25 @@ const tasksAddMultiple = {
         const { projectId, sectionId, parentId, tasks } = args;
         const newTasks = [];
         for (const task of tasks) {
-            const taskArgs = { ...task, projectId, sectionId, parentId };
+            const { duration: durationStr, ...otherTaskArgs } = task;
+            let taskArgs = { ...otherTaskArgs, projectId, sectionId, parentId };
+            // Parse duration if provided
+            if (durationStr) {
+                try {
+                    const { minutes } = parseDuration(durationStr);
+                    taskArgs = {
+                        ...taskArgs,
+                        duration: minutes,
+                        durationUnit: 'minute',
+                    };
+                }
+                catch (error) {
+                    if (error instanceof DurationParseError) {
+                        throw new Error(`Task "${task.content}": ${error.message}`);
+                    }
+                    throw error;
+                }
+            }
             newTasks.push(await client.addTask(taskArgs));
         }
         return newTasks.map(mapTask);

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

@@ -25,6 +25,7 @@ declare const tasksListByDate: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[];
         nextCursor: string | null;
     }>;

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

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

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

@@ -35,6 +35,7 @@ declare const tasksListCompleted: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[];
         nextCursor: string | null;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-list-completed.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-completed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwCvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAekB,CAAA;AAE1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}
+{"version":3,"file":"tasks-list-completed.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-completed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwCvB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAekB,CAAA;AAE1C,OAAO,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/tools/tasks-list-for-container.d.ts

@@ -25,6 +25,7 @@ declare const tasksListForContainer: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[];
         nextCursor: string | null;
     }>;

package/dist/tools/tasks-list-for-container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tasks-list-for-container.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-for-container.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Be,CAAA;AAE1C,OAAO,EAAE,qBAAqB,EAAE,CAAA"}
+{"version":3,"file":"tasks-list-for-container.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-list-for-container.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Be,CAAA;AAE1C,OAAO,EAAE,qBAAqB,EAAE,CAAA"}

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

@@ -23,6 +23,7 @@ declare const tasksSearch: {
             sectionId: string | null;
             parentId: string | null;
             labels: string[];
+            duration: string | null;
         }[];
         nextCursor: string | null;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-search.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAA;AAE1C,OAAO,EAAE,WAAW,EAAE,CAAA"}
+{"version":3,"file":"tasks-search.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAqBvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYyB,CAAA;AAE1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

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

@@ -11,6 +11,7 @@ declare const tasksUpdateOne: {
         parentId: z.ZodOptional<z.ZodString>;
         priority: z.ZodOptional<z.ZodNumber>;
         dueString: z.ZodOptional<z.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
     };
     execute(args: {
         id: string;
@@ -21,6 +22,7 @@ declare const tasksUpdateOne: {
         sectionId?: string | undefined;
         priority?: number | undefined;
         dueString?: string | undefined;
+        duration?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<import("@doist/todoist-api-typescript").Task | undefined>;
 };
 export { tasksUpdateOne };

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

@@ -1 +1 @@
-{"version":3,"file":"tasks-update-one.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-update-one.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwBvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;CAqBsB,CAAA;AAE1C,OAAO,EAAE,cAAc,EAAE,CAAA"}
+{"version":3,"file":"tasks-update-one.d.ts","sourceRoot":"","sources":["../../src/tools/tasks-update-one.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AA+BvB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsB,CAAA;AAE1C,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/tools/tasks-update-one.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { createMoveTaskArgs } from '../tool-helpers.js';
+import { DurationParseError, parseDuration } from '../utils/duration-parser.js';
 const ArgsSchema = {
     id: z.string().min(1).describe('The ID of the task to update.'),
     content: z.string().optional().describe('The new content of the task.'),
@@ -18,13 +19,35 @@ const ArgsSchema = {
         .string()
         .optional()
         .describe("The new due date for the task, in natural language (e.g., 'tomorrow at 5pm')."),
+    duration: z
+        .string()
+        .optional()
+        .describe('The duration of the task. Use format: "2h" (hours), "90m" (minutes), "2h30m" (combined), or "1.5h" (decimal hours). Max 24h.'),
 };
 const tasksUpdateOne = {
     name: 'tasks-update-one',
     description: 'Update an existing task with new values.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { id, projectId, sectionId, parentId, ...updateArgs } = args;
+        const { id, projectId, sectionId, parentId, duration: durationStr, ...otherUpdateArgs } = args;
+        let updateArgs = { ...otherUpdateArgs };
+        // Parse duration if provided
+        if (durationStr) {
+            try {
+                const { minutes } = parseDuration(durationStr);
+                updateArgs = {
+                    ...updateArgs,
+                    duration: minutes,
+                    durationUnit: 'minute',
+                };
+            }
+            catch (error) {
+                if (error instanceof DurationParseError) {
+                    throw new Error(`Task ${id}: ${error.message}`);
+                }
+                throw error;
+            }
+        }
         // If no move parameters are provided, use updateTask without moveTasks
         if (!projectId && !sectionId && !parentId) {
             return await client.updateTask(id, updateArgs);

package/dist/tools/test-helpers.d.ts

@@ -14,6 +14,7 @@ export type MappedTask = {
     sectionId: string | null;
     parentId: string | null;
     labels: string[];
+    duration: string | null;
 };
 /**
  * Creates a mock Task with all required properties and sensible defaults.

package/dist/tools/test-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/tools/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAA;AAEnF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,MAAM,EAAE,CAAA;CACnB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,OAAO,CAAC,IAAI,CAAM,GAAG,IAAI,CA8BlE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,OAAO,CAAM,GAAG,OAAO,CAe3E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,eAAe,CAAM,GAAG,eAAe,CAuB3F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACnC,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,GAAE,MAAM,GAAG,IAAW,GACjC;IACC,OAAO,EAAE,CAAC,EAAE,CAAA;IACZ,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B,CAKA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAchF;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;CAKd,CAAA;AAEV;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAC1C,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;UAAjC,MAAM;WAAS,CAAC;eAAa,CAAC;IAGtD;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAA"}
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/tools/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAA;AAEnF;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,OAAO,CAAC,IAAI,CAAM,GAAG,IAAI,CA8BlE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,OAAO,CAAM,GAAG,OAAO,CAe3E;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,eAAe,CAAM,GAAG,eAAe,CAuB3F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACnC,OAAO,EAAE,CAAC,EAAE,EACZ,UAAU,GAAE,MAAM,GAAG,IAAW,GACjC;IACC,OAAO,EAAE,CAAC,EAAE,CAAA;IACZ,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B,CAKA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,GAAE,OAAO,CAAC,UAAU,CAAM,GAAG,UAAU,CAehF;AAED;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;CAKd,CAAA;AAEV;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,OAAO,EAC1C,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;CAAE,CAAC;UAAjC,MAAM;WAAS,CAAC;eAAa,CAAC;IAGtD;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAA"}

package/dist/tools/test-helpers.js

@@ -105,6 +105,7 @@ export function createMappedTask(overrides = {}) {
         sectionId: null,
         parentId: null,
         labels: [],
+        duration: null,
         ...overrides,
     };
 }

package/dist/utils/duration-parser.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Duration parser utility for converting human-readable duration strings
+ * to minutes using a restricted, language-neutral syntax.
+ *
+ * Supported formats:
+ * - "2h" (hours only)
+ * - "90m" (minutes only)
+ * - "2h30m" (hours + minutes)
+ * - "1.5h" (decimal hours)
+ * - Supports optional spaces: "2h 30m"
+ */
+interface ParsedDuration {
+    minutes: number;
+}
+export declare class DurationParseError extends Error {
+    constructor(input: string, reason: string);
+}
+/**
+ * Parses duration string in restricted syntax to minutes.
+ * Max duration: 1440 minutes (24 hours)
+ *
+ * @param durationStr - Duration string like "2h30m", "45m", "1.5h"
+ * @returns Parsed duration in minutes
+ * @throws DurationParseError for invalid formats
+ */
+export declare function parseDuration(durationStr: string): ParsedDuration;
+/**
+ * Formats minutes back to a human-readable duration string.
+ * Used when returning task data to LLMs.
+ *
+ * @param minutes - Duration in minutes
+ * @returns Formatted duration string like "2h30m" or "45m"
+ */
+export declare function formatDuration(minutes: number): string;
+export {};
+//# sourceMappingURL=duration-parser.d.ts.map

package/dist/utils/duration-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration-parser.d.ts","sourceRoot":"","sources":["../../src/utils/duration-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,UAAU,cAAc;IACpB,OAAO,EAAE,MAAM,CAAA;CAClB;AAED,qBAAa,kBAAmB,SAAQ,KAAK;gBAC7B,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAI5C;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAgEjE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAetD"}

package/dist/utils/duration-parser.js

@@ -0,0 +1,96 @@
+/**
+ * Duration parser utility for converting human-readable duration strings
+ * to minutes using a restricted, language-neutral syntax.
+ *
+ * Supported formats:
+ * - "2h" (hours only)
+ * - "90m" (minutes only)
+ * - "2h30m" (hours + minutes)
+ * - "1.5h" (decimal hours)
+ * - Supports optional spaces: "2h 30m"
+ */
+export class DurationParseError extends Error {
+    constructor(input, reason) {
+        super(`Invalid duration format "${input}": ${reason}`);
+        this.name = 'DurationParseError';
+    }
+}
+/**
+ * Parses duration string in restricted syntax to minutes.
+ * Max duration: 1440 minutes (24 hours)
+ *
+ * @param durationStr - Duration string like "2h30m", "45m", "1.5h"
+ * @returns Parsed duration in minutes
+ * @throws DurationParseError for invalid formats
+ */
+export function parseDuration(durationStr) {
+    if (!durationStr || typeof durationStr !== 'string') {
+        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
+    }
+    // Remove all spaces and convert to lowercase
+    const normalized = durationStr.trim().toLowerCase().replace(/\s+/g, '');
+    // Check for empty string after trimming
+    if (!normalized) {
+        throw new DurationParseError(durationStr, 'Duration must be a non-empty string');
+    }
+    // Validate format with strict ordering: hours must come before minutes
+    // This regex ensures: optional hours followed by optional minutes, no duplicates
+    const match = normalized.match(/^(?:(\d+(?:\.\d+)?)h)?(?:(\d+(?:\.\d+)?)m)?$/);
+    if (!match || (!match[1] && !match[2])) {
+        throw new DurationParseError(durationStr, 'Use format like "2h", "30m", "2h30m", or "1.5h"');
+    }
+    let totalMinutes = 0;
+    const [, hoursStr, minutesStr] = match;
+    // Parse hours if present
+    if (hoursStr) {
+        const hours = Number.parseFloat(hoursStr);
+        if (Number.isNaN(hours) || hours < 0) {
+            throw new DurationParseError(durationStr, 'Hours must be a positive number');
+        }
+        totalMinutes += hours * 60;
+    }
+    // Parse minutes if present
+    if (minutesStr) {
+        const minutes = Number.parseFloat(minutesStr);
+        if (Number.isNaN(minutes) || minutes < 0) {
+            throw new DurationParseError(durationStr, 'Minutes must be a positive number');
+        }
+        // Don't allow decimal minutes
+        if (minutes % 1 !== 0) {
+            throw new DurationParseError(durationStr, 'Minutes must be a whole number (use decimal hours instead)');
+        }
+        totalMinutes += minutes;
+    }
+    // The regex already ensures at least one unit is present
+    // Round to nearest minute (handles decimal hours)
+    totalMinutes = Math.round(totalMinutes);
+    // Validate minimum duration
+    if (totalMinutes === 0) {
+        throw new DurationParseError(durationStr, 'Duration must be greater than 0 minutes');
+    }
+    // Validate maximum duration (24 hours = 1440 minutes)
+    if (totalMinutes > 1440) {
+        throw new DurationParseError(durationStr, 'Duration cannot exceed 24 hours (1440 minutes)');
+    }
+    return { minutes: totalMinutes };
+}
+/**
+ * Formats minutes back to a human-readable duration string.
+ * Used when returning task data to LLMs.
+ *
+ * @param minutes - Duration in minutes
+ * @returns Formatted duration string like "2h30m" or "45m"
+ */
+export function formatDuration(minutes) {
+    if (minutes <= 0)
+        return '0m';
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    if (hours === 0) {
+        return `${remainingMinutes}m`;
+    }
+    if (remainingMinutes === 0) {
+        return `${hours}h`;
+    }
+    return `${hours}h${remainingMinutes}m`;
+}

package/dist/utils/duration-parser.test.d.ts

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

package/dist/utils/duration-parser.test.d.ts.map

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

package/dist/utils/duration-parser.test.js

@@ -0,0 +1,147 @@
+import { DurationParseError, formatDuration, parseDuration } from './duration-parser.js';
+describe('parseDuration', () => {
+    describe('valid formats', () => {
+        it('should parse hours only', () => {
+            expect(parseDuration('2h')).toEqual({ minutes: 120 });
+            expect(parseDuration('1h')).toEqual({ minutes: 60 });
+            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
+        });
+        it('should parse minutes only', () => {
+            expect(parseDuration('90m')).toEqual({ minutes: 90 });
+            expect(parseDuration('45m')).toEqual({ minutes: 45 });
+            expect(parseDuration('1m')).toEqual({ minutes: 1 });
+            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
+        });
+        it('should parse hours and minutes combined', () => {
+            expect(parseDuration('2h30m')).toEqual({ minutes: 150 });
+            expect(parseDuration('1h45m')).toEqual({ minutes: 105 });
+            expect(parseDuration('0h30m')).toEqual({ minutes: 30 });
+            expect(parseDuration('23h59m')).toEqual({ minutes: 1439 });
+        });
+        it('should parse decimal hours', () => {
+            expect(parseDuration('1.5h')).toEqual({ minutes: 90 });
+            expect(parseDuration('2.25h')).toEqual({ minutes: 135 });
+            expect(parseDuration('0.5h')).toEqual({ minutes: 30 });
+            expect(parseDuration('0.75h')).toEqual({ minutes: 45 });
+        });
+        it('should handle spaces in input', () => {
+            expect(parseDuration('2h 30m')).toEqual({ minutes: 150 });
+            expect(parseDuration(' 1h45m ')).toEqual({ minutes: 105 });
+            expect(parseDuration('  2h  ')).toEqual({ minutes: 120 });
+            expect(parseDuration(' 90m ')).toEqual({ minutes: 90 });
+        });
+        it('should handle case insensitive input', () => {
+            expect(parseDuration('2H')).toEqual({ minutes: 120 });
+            expect(parseDuration('90M')).toEqual({ minutes: 90 });
+            expect(parseDuration('2H30M')).toEqual({ minutes: 150 });
+            expect(parseDuration('1.5H')).toEqual({ minutes: 90 });
+        });
+        it('should round decimal minutes from decimal hours', () => {
+            expect(parseDuration('1.33h')).toEqual({ minutes: 80 }); // 1.33 * 60 = 79.8 -> 80
+            expect(parseDuration('1.67h')).toEqual({ minutes: 100 }); // 1.67 * 60 = 100.2 -> 100
+        });
+    });
+    describe('invalid formats', () => {
+        it('should throw error for empty or null input', () => {
+            expect(() => parseDuration('')).toThrow(DurationParseError);
+            expect(() => parseDuration('   ')).toThrow('Duration must be a non-empty string');
+            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
+            expect(() => parseDuration(null)).toThrow('Duration must be a non-empty string');
+            // biome-ignore lint/suspicious/noExplicitAny: Testing error cases with invalid types
+            expect(() => parseDuration(undefined)).toThrow('Duration must be a non-empty string');
+        });
+        it('should throw error for invalid format', () => {
+            expect(() => parseDuration('2')).toThrow('Use format like "2h", "30m", "2h30m", or "1.5h"');
+            expect(() => parseDuration('2hours')).toThrow('Use format like');
+            expect(() => parseDuration('2h30')).toThrow('Use format like');
+            expect(() => parseDuration('h30m')).toThrow('Use format like');
+            expect(() => parseDuration('2x30m')).toThrow('Use format like');
+            expect(() => parseDuration('2h30s')).toThrow('Use format like');
+        });
+        it('should throw error for decimal minutes', () => {
+            expect(() => parseDuration('90.5m')).toThrow('Minutes must be a whole number');
+            expect(() => parseDuration('1h30.5m')).toThrow('Minutes must be a whole number');
+        });
+        it('should throw error for negative values', () => {
+            expect(() => parseDuration('-2h')).toThrow('Use format like');
+            expect(() => parseDuration('-30m')).toThrow('Use format like');
+            expect(() => parseDuration('2h-30m')).toThrow('Use format like');
+        });
+        it('should throw error for zero duration', () => {
+            expect(() => parseDuration('0h')).toThrow('Duration must be greater than 0 minutes');
+            expect(() => parseDuration('0m')).toThrow('Duration must be greater than 0 minutes');
+            expect(() => parseDuration('0h0m')).toThrow('Duration must be greater than 0 minutes');
+        });
+        it('should throw error for duration exceeding 24 hours', () => {
+            expect(() => parseDuration('25h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
+            expect(() => parseDuration('1441m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
+            expect(() => parseDuration('24h1m')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
+            expect(() => parseDuration('24.1h')).toThrow('Duration cannot exceed 24 hours (1440 minutes)');
+        });
+        it('should throw error for malformed numbers', () => {
+            expect(() => parseDuration('2.h')).toThrow('Use format like');
+            expect(() => parseDuration('2h.m')).toThrow('Use format like');
+            expect(() => parseDuration('2..5h')).toThrow('Use format like');
+        });
+        it('should throw error for duplicate units', () => {
+            expect(() => parseDuration('2h3h')).toThrow('Use format like');
+            expect(() => parseDuration('30m45m')).toThrow('Use format like');
+        });
+        it('should throw error for wrong order (minutes before hours)', () => {
+            expect(() => parseDuration('30m2h')).toThrow('Use format like');
+            expect(() => parseDuration('45m1h')).toThrow('Use format like');
+        });
+        it('should throw error for invalid mixed formats with correct order', () => {
+            expect(() => parseDuration('2h30m15h')).toThrow('Use format like');
+            expect(() => parseDuration('1h2h30m')).toThrow('Use format like');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle maximum allowed duration', () => {
+            expect(parseDuration('24h')).toEqual({ minutes: 1440 });
+            expect(parseDuration('1440m')).toEqual({ minutes: 1440 });
+            expect(parseDuration('23h60m')).toEqual({ minutes: 1440 });
+        });
+        it('should handle minimum allowed duration', () => {
+            expect(parseDuration('1m')).toEqual({ minutes: 1 });
+            expect(parseDuration('0.017h')).toEqual({ minutes: 1 }); // 0.017 * 60 = 1.02 -> 1
+        });
+    });
+});
+describe('formatDuration', () => {
+    it('should format minutes only', () => {
+        expect(formatDuration(45)).toBe('45m');
+        expect(formatDuration(1)).toBe('1m');
+        expect(formatDuration(59)).toBe('59m');
+    });
+    it('should format hours only', () => {
+        expect(formatDuration(60)).toBe('1h');
+        expect(formatDuration(120)).toBe('2h');
+        expect(formatDuration(1440)).toBe('24h');
+    });
+    it('should format hours and minutes combined', () => {
+        expect(formatDuration(90)).toBe('1h30m');
+        expect(formatDuration(150)).toBe('2h30m');
+        expect(formatDuration(105)).toBe('1h45m');
+        expect(formatDuration(1439)).toBe('23h59m');
+    });
+    it('should handle edge cases', () => {
+        expect(formatDuration(0)).toBe('0m');
+        expect(formatDuration(-5)).toBe('0m');
+    });
+});
+describe('round trip parsing and formatting', () => {
+    const testCases = [
+        { input: '2h', expectedMinutes: 120, expectedFormat: '2h' },
+        { input: '45m', expectedMinutes: 45, expectedFormat: '45m' },
+        { input: '2h30m', expectedMinutes: 150, expectedFormat: '2h30m' },
+        { input: '1.5h', expectedMinutes: 90, expectedFormat: '1h30m' },
+    ];
+    for (const { input, expectedMinutes, expectedFormat } of testCases) {
+        it(`should parse "${input}" and format back consistently`, () => {
+            const parsed = parseDuration(input);
+            expect(parsed.minutes).toBe(expectedMinutes);
+            expect(formatDuration(parsed.minutes)).toBe(expectedFormat);
+        });
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "2.0.1",
+    "version": "2.1.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",