@doist/todoist-ai 4.9.3 → 4.10.0

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/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;AA2CvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AAgI1C,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;AAqDvB,QAAA,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuB4B,CAAA;AAgI1C,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/dist/tools/add-tasks.js

@@ -7,8 +7,14 @@ import { convertPriorityToNumber, PrioritySchema } from '../utils/priorities.js'
 import { generateTaskNextSteps, getDateString, summarizeTaskOperation, } from '../utils/response-builders.js';
 import { ToolNames } from '../utils/tool-names.js';
 const TaskSchema = z.object({
-    content: z.string().min(1).describe('The content of the task to create.'),
-    description: z.string().optional().describe('The description of the task.'),
+    content: z
+        .string()
+        .min(1)
+        .describe('The task name/title. Should be concise and actionable (e.g., "Review PR #123", "Call dentist"). For longer content, use the description field instead. Supports Markdown.'),
+    description: z
+        .string()
+        .optional()
+        .describe('Additional details, notes, or context for the task. Use this for longer content rather than putting it in the task name. Supports Markdown.'),
     priority: PrioritySchema.optional().describe('The priority of the task: p1 (highest), p2 (high), p3 (medium), p4 (lowest/default).'),
     dueString: z.string().optional().describe('The due date for the task, in natural language.'),
     duration: z

package/dist/tools/fetch.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+type FetchToolOutput = {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+};
+/**
+ * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
+ *
+ * This tool follows the OpenAI MCP fetch tool specification:
+ * @see https://platform.openai.com/docs/mcp#fetch-tool
+ */
+declare const fetch: {
+    name: "fetch";
+    description: string;
+    parameters: {
+        id: z.ZodString;
+    };
+    execute(args: {
+        id: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<FetchToolOutput>;
+};
+export { fetch };
+//# sourceMappingURL=fetch.d.ts.map

package/dist/tools/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../src/tools/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,KAAK,eAAe,GAAG;IACnB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,KAAK;;;;;;;;oEAKsB,OAAO,CAAC,eAAe,CAAC;CAsFf,CAAA;AAE1C,OAAO,EAAE,KAAK,EAAE,CAAA"}

package/dist/tools/fetch.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { getErrorOutput } from '../mcp-helpers.js';
+import { buildTodoistUrl, mapProject, mapTask } from '../tool-helpers.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    id: z
+        .string()
+        .min(1)
+        .describe('A unique identifier for the document in the format "task:{id}" or "project:{id}".'),
+};
+/**
+ * OpenAI MCP fetch tool - retrieves the full contents of a task or project by ID.
+ *
+ * This tool follows the OpenAI MCP fetch tool specification:
+ * @see https://platform.openai.com/docs/mcp#fetch-tool
+ */
+const fetch = {
+    name: ToolNames.FETCH,
+    description: 'Fetch the full contents of a task or project by its ID. The ID should be in the format "task:{id}" or "project:{id}".',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        try {
+            const { id } = args;
+            // Parse the composite ID
+            const [type, objectId] = id.split(':', 2);
+            if (!objectId || (type !== 'task' && type !== 'project')) {
+                throw new Error('Invalid ID format. Expected "task:{id}" or "project:{id}". Example: "task:8485093748" or "project:6cfCcrrCFg2xP94Q"');
+            }
+            let result;
+            if (type === 'task') {
+                // Fetch task
+                const task = await client.getTask(objectId);
+                const mappedTask = mapTask(task);
+                // Build text content
+                const textParts = [mappedTask.content];
+                if (mappedTask.description) {
+                    textParts.push(`\n\nDescription: ${mappedTask.description}`);
+                }
+                if (mappedTask.dueDate) {
+                    textParts.push(`\nDue: ${mappedTask.dueDate}`);
+                }
+                if (mappedTask.labels.length > 0) {
+                    textParts.push(`\nLabels: ${mappedTask.labels.join(', ')}`);
+                }
+                result = {
+                    id: `task:${mappedTask.id}`,
+                    title: mappedTask.content,
+                    text: textParts.join(''),
+                    url: buildTodoistUrl('task', mappedTask.id),
+                    metadata: {
+                        priority: mappedTask.priority,
+                        projectId: mappedTask.projectId,
+                        sectionId: mappedTask.sectionId,
+                        parentId: mappedTask.parentId,
+                        recurring: mappedTask.recurring,
+                        duration: mappedTask.duration,
+                        responsibleUid: mappedTask.responsibleUid,
+                        assignedByUid: mappedTask.assignedByUid,
+                    },
+                };
+            }
+            else {
+                // Fetch project
+                const project = await client.getProject(objectId);
+                const mappedProject = mapProject(project);
+                // Build text content
+                const textParts = [mappedProject.name];
+                if (mappedProject.isShared) {
+                    textParts.push('\n\nShared project');
+                }
+                if (mappedProject.isFavorite) {
+                    textParts.push('\nFavorite: Yes');
+                }
+                result = {
+                    id: `project:${mappedProject.id}`,
+                    title: mappedProject.name,
+                    text: textParts.join(''),
+                    url: buildTodoistUrl('project', mappedProject.id),
+                    metadata: {
+                        color: mappedProject.color,
+                        isFavorite: mappedProject.isFavorite,
+                        isShared: mappedProject.isShared,
+                        parentId: mappedProject.parentId,
+                        inboxProject: mappedProject.inboxProject,
+                        viewStyle: mappedProject.viewStyle,
+                    },
+                };
+            }
+            // Return as JSON-encoded string in a text content item (OpenAI MCP spec)
+            const jsonText = JSON.stringify(result);
+            return { content: [{ type: 'text', text: jsonText }] };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'An unknown error occurred';
+            return getErrorOutput(message);
+        }
+    },
+};
+export { fetch };

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

@@ -9,8 +9,8 @@ declare const findProjects: {
     };
     execute(args: {
         limit: number;
-        cursor?: string | undefined;
         search?: string | undefined;
+        cursor?: string | undefined;
     }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
         content: {
             type: "text";
@@ -32,8 +32,8 @@ declare const findProjects: {
             hasMore: boolean;
             appliedFilters: {
                 limit: number;
-                cursor?: string | undefined;
                 search?: string | undefined;
+                cursor?: string | undefined;
             };
         };
     } | {

package/dist/tools/search.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+type SearchToolOutput = {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+};
+/**
+ * OpenAI MCP search tool - returns a list of relevant search results from Todoist.
+ *
+ * This tool follows the OpenAI MCP search tool specification:
+ * @see https://platform.openai.com/docs/mcp#search-tool
+ */
+declare const search: {
+    name: "search";
+    description: string;
+    parameters: {
+        query: z.ZodString;
+    };
+    execute(args: {
+        query: string;
+    }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<SearchToolOutput>;
+};
+export { search };
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/tools/search.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,KAAK,gBAAgB,GAAG;IACpB,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,MAAM;;;;;;;;oEAKqB,OAAO,CAAC,gBAAgB,CAAC;CAmDhB,CAAA;AAE1C,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/tools/search.js

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { getErrorOutput } from '../mcp-helpers.js';
+import { buildTodoistUrl, getTasksByFilter } from '../tool-helpers.js';
+import { ApiLimits } from '../utils/constants.js';
+import { ToolNames } from '../utils/tool-names.js';
+const ArgsSchema = {
+    query: z.string().min(1).describe('The search query string to find tasks and projects.'),
+};
+/**
+ * OpenAI MCP search tool - returns a list of relevant search results from Todoist.
+ *
+ * This tool follows the OpenAI MCP search tool specification:
+ * @see https://platform.openai.com/docs/mcp#search-tool
+ */
+const search = {
+    name: ToolNames.SEARCH,
+    description: 'Search across tasks and projects in Todoist. Returns a list of relevant results with IDs, titles, and URLs.',
+    parameters: ArgsSchema,
+    async execute(args, client) {
+        try {
+            const { query } = args;
+            // Search both tasks and projects in parallel
+            // Use TASKS_MAX for search since this tool doesn't support pagination
+            const [tasksResult, projectsResponse] = await Promise.all([
+                getTasksByFilter({
+                    client,
+                    query: `search: ${query}`,
+                    limit: ApiLimits.TASKS_MAX,
+                    cursor: undefined,
+                }),
+                client.getProjects({ limit: ApiLimits.PROJECTS_MAX }),
+            ]);
+            // Filter projects by search query (case-insensitive)
+            const searchLower = query.toLowerCase();
+            const matchingProjects = projectsResponse.results.filter((project) => project.name.toLowerCase().includes(searchLower));
+            // Build results array
+            const results = [];
+            // Add task results with composite IDs
+            for (const task of tasksResult.tasks) {
+                results.push({
+                    id: `task:${task.id}`,
+                    title: task.content,
+                    url: buildTodoistUrl('task', task.id),
+                });
+            }
+            // Add project results with composite IDs
+            for (const project of matchingProjects) {
+                results.push({
+                    id: `project:${project.id}`,
+                    title: project.name,
+                    url: buildTodoistUrl('project', project.id),
+                });
+            }
+            // Return as JSON-encoded string in a text content item (OpenAI MCP spec)
+            const jsonText = JSON.stringify({ results });
+            return { content: [{ type: 'text', text: jsonText }] };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'An unknown error occurred';
+            return getErrorOutput(message);
+        }
+    },
+};
+export { search };

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;AAoDvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkHyB,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;AA8DvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkHyB,CAAA;AAqC1C,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/tools/update-tasks.js

@@ -9,8 +9,14 @@ import { ToolNames } from '../utils/tool-names.js';
 const { FIND_TASKS_BY_DATE, GET_OVERVIEW } = ToolNames;
 const TasksUpdateSchema = z.object({
     id: z.string().min(1).describe('The ID of the task to update.'),
-    content: z.string().optional().describe('The new content of the task.'),
-    description: z.string().optional().describe('The new description of the task.'),
+    content: z
+        .string()
+        .optional()
+        .describe('The new task name/title. Should be concise and actionable (e.g., "Review PR #123", "Call dentist"). For longer content, use the description field instead. Supports Markdown.'),
+    description: z
+        .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.'),
     sectionId: z.string().optional().describe('The new section ID for the task.'),
     parentId: z.string().optional().describe('The new parent task ID (for subtasks).'),

package/dist/utils/constants.d.ts

@@ -8,7 +8,7 @@ export declare const ApiLimits: {
     /** Default limit for task listings */
     readonly TASKS_DEFAULT: 10;
     /** Maximum limit for task search and list operations */
-    readonly TASKS_MAX: 50;
+    readonly TASKS_MAX: 100;
     /** Default limit for completed tasks */
     readonly COMPLETED_TASKS_DEFAULT: 50;
     /** Maximum limit for completed tasks */

package/dist/utils/constants.js

@@ -9,7 +9,7 @@ export const ApiLimits = {
     /** Default limit for task listings */
     TASKS_DEFAULT: 10,
     /** Maximum limit for task search and list operations */
-    TASKS_MAX: 50,
+    TASKS_MAX: 100,
     /** Default limit for completed tasks */
     COMPLETED_TASKS_DEFAULT: 50,
     /** Maximum limit for completed tasks */

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/dist/utils/tool-names.d.ts

@@ -26,6 +26,8 @@ export declare const ToolNames: {
     readonly GET_OVERVIEW: "get-overview";
     readonly DELETE_OBJECT: "delete-object";
     readonly USER_INFO: "user-info";
+    readonly SEARCH: "search";
+    readonly FETCH: "fetch";
 };
 export type ToolName = (typeof ToolNames)[keyof typeof ToolNames];
 //# sourceMappingURL=tool-names.d.ts.map

package/dist/utils/tool-names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;CAgCZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"tool-names.d.ts","sourceRoot":"","sources":["../../src/utils/tool-names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;CAoCZ,CAAA;AAGV,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAA"}

package/dist/utils/tool-names.js

@@ -32,4 +32,7 @@ export const ToolNames = {
     GET_OVERVIEW: 'get-overview',
     DELETE_OBJECT: 'delete-object',
     USER_INFO: 'user-info',
+    // OpenAI MCP tools
+    SEARCH: 'search',
+    FETCH: 'fetch',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/todoist-ai",
-    "version": "4.9.3",
+    "version": "4.10.0",
     "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",