@doist/todoist-ai 4.9.0 → 4.9.2

package/dist/index.d.ts

@@ -257,6 +257,7 @@ declare const tools: {
             sectionId: import("zod").ZodOptional<import("zod").ZodString>;
             parentId: import("zod").ZodOptional<import("zod").ZodString>;
             responsibleUser: import("zod").ZodOptional<import("zod").ZodString>;
+            responsibleUserFiltering: import("zod").ZodOptional<import("zod").ZodEnum<["assigned", "unassignedOrMe", "all"]>>;
             limit: import("zod").ZodDefault<import("zod").ZodNumber>;
             cursor: import("zod").ZodOptional<import("zod").ZodString>;
         };
@@ -264,6 +265,7 @@ declare const tools: {
             limit: number;
             projectId?: string | undefined;
             parentId?: string | undefined;
+            responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
             sectionId?: string | undefined;
             labels?: string[] | undefined;
             cursor?: string | undefined;
@@ -298,6 +300,7 @@ declare const tools: {
                     limit: number;
                     projectId?: string | undefined;
                     parentId?: string | undefined;
+                    responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
                     sectionId?: string | undefined;
                     labels?: string[] | undefined;
                     cursor?: string | 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/tool-helpers.d.ts

@@ -1,7 +1,26 @@
-import { type MoveTaskArgs, type PersonalProject, type Task, type TodoistApi, type WorkspaceProject } from '@doist/todoist-api-typescript';
+import type { MoveTaskArgs, PersonalProject, Task, TodoistApi, WorkspaceProject } from '@doist/todoist-api-typescript';
+export declare const RESPONSIBLE_USER_FILTERING: readonly ["assigned", "unassignedOrMe", "all"];
+export type ResponsibleUserFiltering = (typeof RESPONSIBLE_USER_FILTERING)[number];
 export type Project = PersonalProject | WorkspaceProject;
 export declare function isPersonalProject(project: Project): project is PersonalProject;
 export declare function isWorkspaceProject(project: Project): project is WorkspaceProject;
+/**
+ * Filters tasks based on responsible user logic:
+ * - If resolvedAssigneeId is provided: returns only tasks assigned to that user
+ * - If no resolvedAssigneeId: returns only unassigned tasks or tasks assigned to current user
+ * @param tasks - Array of tasks to filter (must have responsibleUid property)
+ * @param resolvedAssigneeId - The resolved assignee ID to filter by (optional)
+ * @param currentUserId - The current authenticated user's ID
+ * @returns Filtered array of tasks
+ */
+export declare function filterTasksByResponsibleUser<T extends {
+    responsibleUid: string | null;
+}>({ tasks, resolvedAssigneeId, currentUserId, responsibleUserFiltering, }: {
+    tasks: T[];
+    resolvedAssigneeId: string | undefined;
+    currentUserId: string;
+    responsibleUserFiltering?: ResponsibleUserFiltering;
+}): T[];
 /**
  * Creates a MoveTaskArgs object from move parameters, validating that exactly one is provided.
  * @param taskId - The task ID (used for error messages)

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,EAEH,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,IAAI,EACT,KAAK,UAAU,EACf,KAAK,gBAAgB,EACxB,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;;;;;;;;;;;;;;EAgB1B;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,KAAK,EACR,YAAY,EACZ,eAAe,EACf,IAAI,EACJ,UAAU,EACV,gBAAgB,EACnB,MAAM,+BAA+B,CAAA;AAItC,eAAO,MAAM,0BAA0B,gDAAiD,CAAA;AACxF,MAAM,MAAM,wBAAwB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAA;AAElF,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,4BAA4B,CAAC,CAAC,SAAS;IAAE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,EACtF,KAAK,EACL,kBAAkB,EAClB,aAAa,EACb,wBAA2C,GAC9C,EAAE;IACC,KAAK,EAAE,CAAC,EAAE,CAAA;IACV,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,wBAAwB,CAAC,EAAE,wBAAwB,CAAA;CACtD,GAAG,CAAC,EAAE,CAUN;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;;;;;;;;;;;;;;EAgB1B;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,12 +1,33 @@
-import { getSanitizedContent, } from '@doist/todoist-api-typescript';
 import z from 'zod';
 import { formatDuration } from './utils/duration-parser.js';
+export const RESPONSIBLE_USER_FILTERING = ['assigned', 'unassignedOrMe', 'all'];
 export function isPersonalProject(project) {
     return 'inboxProject' in project;
 }
 export function isWorkspaceProject(project) {
     return 'accessLevel' in project;
 }
+/**
+ * Filters tasks based on responsible user logic:
+ * - If resolvedAssigneeId is provided: returns only tasks assigned to that user
+ * - If no resolvedAssigneeId: returns only unassigned tasks or tasks assigned to current user
+ * @param tasks - Array of tasks to filter (must have responsibleUid property)
+ * @param resolvedAssigneeId - The resolved assignee ID to filter by (optional)
+ * @param currentUserId - The current authenticated user's ID
+ * @returns Filtered array of tasks
+ */
+export function filterTasksByResponsibleUser({ tasks, resolvedAssigneeId, currentUserId, responsibleUserFiltering = 'unassignedOrMe', }) {
+    if (resolvedAssigneeId) {
+        // If responsibleUser provided, only return tasks assigned to that user
+        return tasks.filter((task) => task.responsibleUid === resolvedAssigneeId);
+    }
+    else {
+        // If no responsibleUser, only return unassigned tasks or tasks assigned to current user
+        return responsibleUserFiltering === 'unassignedOrMe'
+            ? tasks.filter((task) => !task.responsibleUid || task.responsibleUid === currentUserId)
+            : tasks;
+    }
+}
 /**
  * Creates a MoveTaskArgs object from move parameters, validating that exactly one is provided.
  * @param taskId - The task ID (used for error messages)
@@ -43,8 +64,8 @@ export function createMoveTaskArgs(taskId, projectId, sectionId, parentId) {
 function mapTask(task) {
     return {
         id: task.id,
-        content: getSanitizedContent(task.content),
-        description: getSanitizedContent(task.description),
+        content: task.content,
+        description: task.description,
         dueDate: task.due?.date,
         recurring: task.due?.isRecurring && task.due.string ? task.due.string : false,
         priority: task.priority,

package/dist/tool-helpers.test.js

@@ -73,6 +73,53 @@ describe('shared utilities', () => {
             const result = mapTask(mockTask);
             expect(result.duration).toBe('2h30m');
         });
+        it('should preserve markdown links and formatting in content and description', () => {
+            const mockTask = {
+                id: '123',
+                content: 'Task with **bold** and [link](https://example.com)',
+                description: `Rich markdown description:
+
+### Links
+[Wikipedia](https://en.wikipedia.org/wiki/Test)
+[GitHub](https://github.com/example/repo)
+
+### Formatting
+**Bold text**
+*Italic text*
+\`code block\`
+
+End of description.`,
+                projectId: 'proj-1',
+                sectionId: null,
+                parentId: null,
+                labels: [],
+                priority: 1,
+            };
+            const result = mapTask(mockTask);
+            // Verify exact preservation of markdown content
+            expect(result.content).toBe('Task with **bold** and [link](https://example.com)');
+            expect(result.description).toBe(`Rich markdown description:
+
+### Links
+[Wikipedia](https://en.wikipedia.org/wiki/Test)
+[GitHub](https://github.com/example/repo)
+
+### Formatting
+**Bold text**
+*Italic text*
+\`code block\`
+
+End of description.`);
+            // Verify specific URLs are preserved
+            expect(result.content).toContain('[link](https://example.com)');
+            expect(result.description).toContain('[Wikipedia](https://en.wikipedia.org/wiki/Test)');
+            expect(result.description).toContain('[GitHub](https://github.com/example/repo)');
+            // Verify other markdown formatting is preserved
+            expect(result.content).toContain('**bold**');
+            expect(result.description).toContain('**Bold text**');
+            expect(result.description).toContain('*Italic text*');
+            expect(result.description).toContain('`code block`');
+        });
     });
     describe('mapProject', () => {
         it('should map a personal project correctly', () => {

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

@@ -448,4 +448,42 @@ describe(`${ADD_TASKS} tool`, () => {
             expect(textContent).toContain(`Use ${GET_OVERVIEW} to see your updated project organization`);
         });
     });
+    describe('tasks without project context', () => {
+        it('should allow creating tasks with only content (goes to Inbox)', async () => {
+            const mockApiResponse = createMockTask({
+                id: '8485093758',
+                content: 'Simple inbox task',
+                url: 'https://todoist.com/showTask?id=8485093758',
+                addedAt: '2025-08-13T22:09:56.123456Z',
+            });
+            mockTodoistApi.addTask.mockResolvedValue(mockApiResponse);
+            const result = await addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Simple inbox task',
+                    },
+                ],
+            }, mockTodoistApi);
+            expect(mockTodoistApi.addTask).toHaveBeenCalledWith({
+                content: 'Simple inbox task',
+                labels: undefined,
+                projectId: undefined,
+                sectionId: undefined,
+                parentId: undefined,
+            });
+            const textContent = extractTextContent(result);
+            expect(textContent).toContain('Added 1 task');
+            expect(textContent).toContain('Simple inbox task');
+        });
+        it('should prevent assignment without project context', async () => {
+            await expect(addTasks.execute({
+                tasks: [
+                    {
+                        content: 'Task with assignment but no project',
+                        responsibleUser: 'user@example.com',
+                    },
+                ],
+            }, mockTodoistApi)).rejects.toThrow('Task "Task with assignment but no project": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.');
+        });
+    });
 });

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

@@ -1,15 +1,23 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { createMappedTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
+import { createMappedTask, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
 import { findTasksByDate } from '../find-tasks-by-date.js';
 // Mock the tool helpers
-jest.mock('../../tool-helpers', () => ({
-    getTasksByFilter: jest.fn(),
-}));
+jest.mock('../../tool-helpers', () => {
+    const actual = jest.requireActual('../../tool-helpers');
+    return {
+        getTasksByFilter: jest.fn(),
+        filterTasksByResponsibleUser: actual.filterTasksByResponsibleUser,
+    };
+});
 const mockGetTasksByFilter = getTasksByFilter;
 // Mock the Todoist API (not directly used by find-tasks-by-date, but needed for type)
-const mockTodoistApi = {};
+const mockTodoistApi = {
+    getUser: jest.fn(),
+};
+// Mock the Todoist User
+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
@@ -30,6 +38,7 @@ const { FIND_TASKS_BY_DATE, UPDATE_TASKS } = ToolNames;
 describe(`${FIND_TASKS_BY_DATE} tool`, () => {
     beforeEach(() => {
         jest.clearAllMocks();
+        mockTodoistApi.getUser.mockResolvedValue(mockTodoistUser);
         // Mock current date to make tests deterministic
         jest.spyOn(Date, 'now').mockReturnValue(new Date('2025-08-15T10:00:00Z').getTime());
     });
@@ -310,6 +319,72 @@ describe(`${FIND_TASKS_BY_DATE} tool`, () => {
             expect(textContent).toMatchSnapshot();
         });
     });
+    describe('responsible user filtering', () => {
+        it('should filter results to show only unassigned tasks or tasks assigned to current user', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'My task',
+                    dueDate: '2025-08-15',
+                    responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Unassigned task',
+                    dueDate: '2025-08-15',
+                    responsibleUid: null, // Unassigned
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_3,
+                    content: 'Someone else task',
+                    dueDate: '2025-08-15',
+                    responsibleUid: 'other-user-id', // Assigned to someone else
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: 'today', daysCount: 1, limit: 50 }, mockTodoistApi);
+            const structuredContent = extractStructuredContent(result);
+            // Should only return tasks 1 and 2, not task 3
+            expect(structuredContent.tasks).toHaveLength(2);
+            expect(structuredContent.tasks.map((t) => t.id)).toEqual([
+                TEST_IDS.TASK_1,
+                TEST_IDS.TASK_2,
+            ]);
+        });
+        it('should filter overdue results to show only unassigned tasks or tasks assigned to current user', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'My overdue task',
+                    dueDate: '2025-08-10',
+                    responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Unassigned overdue task',
+                    dueDate: '2025-08-10',
+                    responsibleUid: null, // Unassigned
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_3,
+                    content: 'Someone else overdue task',
+                    dueDate: '2025-08-10',
+                    responsibleUid: 'other-user-id', // Assigned to someone else
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasksByDate.execute({ startDate: 'overdue', daysCount: 1, limit: 50 }, mockTodoistApi);
+            const structuredContent = extractStructuredContent(result);
+            // Should only return tasks 1 and 2, not task 3
+            expect(structuredContent.tasks).toHaveLength(2);
+            expect(structuredContent.tasks.map((t) => t.id)).toEqual([
+                TEST_IDS.TASK_1,
+                TEST_IDS.TASK_2,
+            ]);
+        });
+    });
     describe('error handling', () => {
         it.each([
             {

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

@@ -1,23 +1,33 @@
 import { jest } from '@jest/globals';
 import { getTasksByFilter } from '../../tool-helpers.js';
-import { createMappedTask, createMockApiResponse, createMockTask, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockTask, createMockUser, extractStructuredContent, extractTextContent, TEST_ERRORS, TEST_IDS, TODAY, } from '../../utils/test-helpers.js';
 import { ToolNames } from '../../utils/tool-names.js';
+import { resolveUserNameToId } from '../../utils/user-resolver.js';
 import { findTasks } from '../find-tasks.js';
 jest.mock('../../tool-helpers', () => {
     const actual = jest.requireActual('../../tool-helpers');
     return {
         getTasksByFilter: jest.fn(),
         mapTask: actual.mapTask,
+        filterTasksByResponsibleUser: actual.filterTasksByResponsibleUser,
     };
 });
+jest.mock('../../utils/user-resolver', () => ({
+    resolveUserNameToId: jest.fn(),
+}));
 const { FIND_TASKS, UPDATE_TASKS, FIND_COMPLETED_TASKS } = ToolNames;
 const mockGetTasksByFilter = getTasksByFilter;
+const mockResolveUserNameToId = resolveUserNameToId;
 // Mock the Todoist API
 const mockTodoistApi = {
     getTasks: jest.fn(),
+    getUser: jest.fn(),
 };
+// Mock the Todoist User
+const mockTodoistUser = createMockUser();
 describe(`${FIND_TASKS} tool`, () => {
     beforeEach(() => {
+        mockTodoistApi.getUser.mockResolvedValue(mockTodoistUser);
         jest.clearAllMocks();
     });
     describe('searching tasks', () => {
@@ -547,6 +557,186 @@ describe(`${FIND_TASKS} tool`, () => {
             }));
         });
     });
+    describe('markdown content preservation', () => {
+        it('should preserve markdown links and formatting in task content and description', async () => {
+            const richMarkdownContent = 'Test **bold** task with [link](https://example.com)';
+            const richMarkdownDescription = `This is a **comprehensive test** of markdown syntax in Todoist task descriptions:
+
+### Links
+[Wikipedia - Test Link](https://en.wikipedia.org/wiki/Test)
+[GitHub Repository](https://github.com/Doist/todoist-ai)
+[Google Search](https://www.google.com)
+
+### Text Formatting
+**Bold text here**
+*Italic text here*
+***Bold and italic***
+\`inline code\`
+
+### Lists
+- Bullet point 1
+- Bullet point 2
+  - Nested item
+
+1. Numbered item 1
+2. Numbered item 2
+
+End of test content.`;
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: richMarkdownContent,
+                    description: richMarkdownDescription,
+                }),
+            ];
+            const mockResponse = { tasks: mockTasks, nextCursor: null };
+            mockGetTasksByFilter.mockResolvedValue(mockResponse);
+            const result = await findTasks.execute({ searchText: 'markdown test', limit: 10 }, mockTodoistApi);
+            const structuredContent = extractStructuredContent(result);
+            // Verify that markdown links and formatting are preserved exactly as provided
+            expect(structuredContent.tasks).toHaveLength(1);
+            expect(structuredContent.tasks).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    content: richMarkdownContent,
+                    description: richMarkdownDescription,
+                }),
+            ]));
+        });
+        it('should preserve markdown links in container-based searches', async () => {
+            const taskWithLinks = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Task with [external link](https://todoist.com)',
+                description: 'See this [documentation](https://docs.example.com) for details.',
+            });
+            mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse([taskWithLinks]));
+            const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_TEST, limit: 10 }, mockTodoistApi);
+            const structuredContent = extractStructuredContent(result);
+            // Verify URLs are preserved in container-based searches too
+            expect(structuredContent.tasks).toHaveLength(1);
+            expect(structuredContent.tasks).toEqual(expect.arrayContaining([
+                expect.objectContaining({
+                    content: 'Task with [external link](https://todoist.com)',
+                    description: 'See this [documentation](https://docs.example.com) for details.',
+                }),
+            ]));
+        });
+    });
+    describe('responsible user filtering', () => {
+        describe('when no responsibleUser is provided', () => {
+            it('should filter text search results to show only unassigned tasks or tasks assigned to current user', async () => {
+                const mockTasks = [
+                    createMappedTask({
+                        id: TEST_IDS.TASK_1,
+                        content: 'My task',
+                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                    }),
+                    createMappedTask({
+                        id: TEST_IDS.TASK_2,
+                        content: 'Unassigned task',
+                        responsibleUid: null, // Unassigned
+                    }),
+                    createMappedTask({
+                        id: TEST_IDS.TASK_3,
+                        content: 'Someone else task',
+                        responsibleUid: 'other-user-id', // Assigned to someone else
+                    }),
+                ];
+                const mockResponse = { tasks: mockTasks, nextCursor: null };
+                mockGetTasksByFilter.mockResolvedValue(mockResponse);
+                const result = await findTasks.execute({ searchText: 'task', limit: 10 }, mockTodoistApi);
+                const structuredContent = extractStructuredContent(result);
+                // Should only return tasks 1 and 2, not task 3
+                expect(structuredContent.tasks).toHaveLength(2);
+                expect(structuredContent.tasks.map((t) => t.id)).toEqual([TEST_IDS.TASK_1, TEST_IDS.TASK_2]);
+            });
+            it('should filter container-based results to show only unassigned tasks or tasks assigned to current user', async () => {
+                const mockTasks = [
+                    createMockTask({
+                        id: TEST_IDS.TASK_1,
+                        content: 'My project task',
+                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                    }),
+                    createMockTask({
+                        id: TEST_IDS.TASK_2,
+                        content: 'Unassigned project task',
+                        responsibleUid: null, // Unassigned
+                    }),
+                    createMockTask({
+                        id: TEST_IDS.TASK_3,
+                        content: 'Someone else project task',
+                        responsibleUid: 'other-user-id', // Assigned to someone else
+                    }),
+                ];
+                mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(mockTasks));
+                const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_WORK, limit: 10 }, mockTodoistApi);
+                const structuredContent = extractStructuredContent(result);
+                // Should only return tasks 1 and 2, not task 3
+                expect(structuredContent.tasks).toHaveLength(2);
+                expect(structuredContent.tasks.map((t) => t.id)).toEqual([TEST_IDS.TASK_1, TEST_IDS.TASK_2]);
+            });
+        });
+        describe('when responsibleUser is provided', () => {
+            it('should filter text search results to show only tasks assigned to specified user', async () => {
+                const mockTasks = [
+                    createMappedTask({
+                        id: TEST_IDS.TASK_1,
+                        content: 'Task for John',
+                        responsibleUid: 'specific-user-id', // Assigned to specified user
+                    }),
+                    createMappedTask({
+                        id: TEST_IDS.TASK_2,
+                        content: 'My task',
+                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                    }),
+                    createMappedTask({
+                        id: TEST_IDS.TASK_3,
+                        content: 'Unassigned task',
+                        responsibleUid: null, // Unassigned
+                    }),
+                ];
+                const mockResponse = { tasks: mockTasks, nextCursor: null };
+                mockGetTasksByFilter.mockResolvedValue(mockResponse);
+                mockResolveUserNameToId.mockResolvedValue({
+                    userId: 'specific-user-id',
+                    displayName: 'John Doe',
+                });
+                const result = await findTasks.execute({ searchText: 'task', responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
+                const structuredContent = extractStructuredContent(result);
+                // Should only return task 1 (assigned to John)
+                expect(structuredContent.tasks).toHaveLength(1);
+                expect(structuredContent.tasks[0]?.id).toBe(TEST_IDS.TASK_1);
+            });
+            it('should filter container-based results to show only tasks assigned to specified user', async () => {
+                const mockTasks = [
+                    createMockTask({
+                        id: TEST_IDS.TASK_1,
+                        content: 'Task for John',
+                        responsibleUid: 'specific-user-id', // Assigned to specified user
+                    }),
+                    createMockTask({
+                        id: TEST_IDS.TASK_2,
+                        content: 'My task',
+                        responsibleUid: TEST_IDS.USER_ID, // Assigned to current user
+                    }),
+                    createMockTask({
+                        id: TEST_IDS.TASK_3,
+                        content: 'Unassigned task',
+                        responsibleUid: null, // Unassigned
+                    }),
+                ];
+                mockTodoistApi.getTasks.mockResolvedValue(createMockApiResponse(mockTasks));
+                mockResolveUserNameToId.mockResolvedValue({
+                    userId: 'specific-user-id',
+                    displayName: 'John Doe',
+                });
+                const result = await findTasks.execute({ projectId: TEST_IDS.PROJECT_WORK, responsibleUser: 'John Doe', limit: 10 }, mockTodoistApi);
+                const structuredContent = extractStructuredContent(result);
+                // Should only return task 1 (assigned to John)
+                expect(structuredContent.tasks).toHaveLength(1);
+                expect(structuredContent.tasks[0]?.id).toBe(TEST_IDS.TASK_1);
+            });
+        });
+    });
     describe('error handling', () => {
         it.each([
             {

package/dist/tools/add-tasks.js

@@ -55,8 +55,8 @@ async function processTask(task, client) {
     if (priority) {
         taskArgs.priority = convertPriorityToNumber(priority);
     }
-    // Prevent assignment to tasks without sufficient project context
-    if (!projectId && !sectionId && !parentId) {
+    // Only prevent assignment (not task creation) without sufficient project context
+    if (responsibleUser && !projectId && !sectionId && !parentId) {
         throw new Error(`Task "${task.content}": Cannot assign tasks without specifying project context. Please specify a projectId, sectionId, or parentId.`);
     }
     // Parse duration if provided

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

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

@@ -1,7 +1,7 @@
 import { addDays, formatISO } from 'date-fns';
 import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
-import { getTasksByFilter } from '../tool-helpers.js';
+import { filterTasksByResponsibleUser, getTasksByFilter } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
 import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
 import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
@@ -37,6 +37,7 @@ const findTasksByDate = {
     parameters: ArgsSchema,
     async execute(args, client) {
         let query = '';
+        const todoistUser = await client.getUser();
         if (args.startDate === 'today') {
             query = 'today | overdue';
         }
@@ -60,17 +61,23 @@ const findTasksByDate = {
             cursor: args.cursor,
             limit: args.limit,
         });
-        const textContent = generateTextContent({
+        // Apply responsible user filtering - only show unassigned tasks or tasks assigned to current user
+        const filteredTasks = filterTasksByResponsibleUser({
             tasks: result.tasks,
+            resolvedAssigneeId: undefined,
+            currentUserId: todoistUser.id,
+        });
+        const textContent = generateTextContent({
+            tasks: filteredTasks,
             args,
             nextCursor: result.nextCursor,
         });
         return getToolOutput({
             textContent,
             structuredContent: {
-                tasks: result.tasks,
+                tasks: filteredTasks,
                 nextCursor: result.nextCursor,
-                totalCount: result.tasks.length,
+                totalCount: filteredTasks.length,
                 hasMore: Boolean(result.nextCursor),
                 appliedFilters: args,
             },

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

@@ -10,6 +10,7 @@ declare const findTasks: {
         sectionId: z.ZodOptional<z.ZodString>;
         parentId: z.ZodOptional<z.ZodString>;
         responsibleUser: z.ZodOptional<z.ZodString>;
+        responsibleUserFiltering: z.ZodOptional<z.ZodEnum<["assigned", "unassignedOrMe", "all"]>>;
         limit: z.ZodDefault<z.ZodNumber>;
         cursor: z.ZodOptional<z.ZodString>;
     };
@@ -17,6 +18,7 @@ declare const findTasks: {
         limit: number;
         projectId?: string | undefined;
         parentId?: string | undefined;
+        responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
         sectionId?: string | undefined;
         labels?: string[] | undefined;
         cursor?: string | undefined;
@@ -51,6 +53,7 @@ declare const findTasks: {
                 limit: number;
                 projectId?: string | undefined;
                 parentId?: string | undefined;
+                responsibleUserFiltering?: "assigned" | "unassignedOrMe" | "all" | undefined;
                 sectionId?: string | undefined;
                 labels?: string[] | undefined;
                 cursor?: string | undefined;

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

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

package/dist/tools/find-tasks.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { getToolOutput } from '../mcp-helpers.js';
-import { getTasksByFilter, mapTask } from '../tool-helpers.js';
+import { filterTasksByResponsibleUser, getTasksByFilter, mapTask, RESPONSIBLE_USER_FILTERING, } from '../tool-helpers.js';
 import { ApiLimits } from '../utils/constants.js';
 import { generateLabelsFilter, LabelsSchema } from '../utils/labels.js';
 import { generateTaskNextSteps, getDateString, previewTasks, summarizeList, } from '../utils/response-builders.js';
@@ -16,6 +16,10 @@ const ArgsSchema = {
         .string()
         .optional()
         .describe('Find tasks assigned to this user. Can be a user ID, name, or email address.'),
+    responsibleUserFiltering: z
+        .enum(RESPONSIBLE_USER_FILTERING)
+        .optional()
+        .describe('How to filter by responsible user when responsibleUser is not provided. "assigned" = only tasks assigned to others; "unassignedOrMe" = only unassigned tasks or tasks assigned to me; "all" = all tasks regardless of assignment. Default value will be `unassignedOrMe`.'),
     limit: z
         .number()
         .int()
@@ -34,7 +38,8 @@ const findTasks = {
     description: 'Find tasks by text search, or by project/section/parent container/responsible user. At least one filter must be provided.',
     parameters: ArgsSchema,
     async execute(args, client) {
-        const { searchText, projectId, sectionId, parentId, responsibleUser, limit, cursor, labels, labelsOperator, } = args;
+        const { searchText, projectId, sectionId, parentId, responsibleUser, responsibleUserFiltering, limit, cursor, labels, labelsOperator, } = args;
+        const todoistUser = await client.getUser();
         // Validate at least one filter is provided
         const hasLabels = labels && labels.length > 0;
         if (!searchText &&
@@ -78,9 +83,12 @@ const findTasks = {
                     task.description?.toLowerCase().includes(searchText.toLowerCase()))
                 : mappedTasks;
             // Apply responsibleUid filter
-            if (resolvedAssigneeId) {
-                filteredTasks = filteredTasks.filter((task) => task.responsibleUid === resolvedAssigneeId);
-            }
+            filteredTasks = filterTasksByResponsibleUser({
+                tasks: filteredTasks,
+                resolvedAssigneeId,
+                currentUserId: todoistUser.id,
+                responsibleUserFiltering,
+            });
             // Apply label filter
             if (labels && labels.length > 0) {
                 filteredTasks =
@@ -156,11 +164,12 @@ const findTasks = {
             cursor: args.cursor,
             limit: args.limit,
         });
-        // Always filter by responsibleUid client-side (API doesn't reliably support responsibleUid filtering)
-        let tasks = result.tasks;
-        if (resolvedAssigneeId) {
-            tasks = result.tasks.filter((task) => task.responsibleUid === resolvedAssigneeId);
-        }
+        const tasks = filterTasksByResponsibleUser({
+            tasks: result.tasks,
+            resolvedAssigneeId,
+            currentUserId: todoistUser.id,
+            responsibleUserFiltering,
+        });
         const textContent = generateTextContent({
             tasks,
             args,

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

@@ -1,4 +1,4 @@
-import type { PersonalProject, Section, Task } from '@doist/todoist-api-typescript';
+import type { CurrentUser, PersonalProject, Section, Task } from '@doist/todoist-api-typescript';
 import { getToolOutput } from '../mcp-helpers';
 /**
  * Mapped task type matching the output of mapTask function.
@@ -95,4 +95,9 @@ export declare const TEST_IDS: {
  * Use this instead of new Date() in tests to avoid snapshot drift.
  */
 export declare const TODAY: "2025-08-17";
+/**
+ * Creates a mock CurrentUser with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export declare function createMockUser(overrides?: Partial<CurrentUser>): CurrentUser;
 //# sourceMappingURL=test-helpers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAA;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;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;IACvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,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,CAgB3E;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,CAiBhF;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;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAqB9D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GACzC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAG,YAAqB,CAAA"}
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/utils/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,+BAA+B,CAAA;AAChG,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAE9C;;;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;IACvB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,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,CAgB3E;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,CAiBhF;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;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,CAqB9D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACpC,MAAM,EAAE,UAAU,CAAC,OAAO,aAAa,CAAC,GACzC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuBzB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;CAUX,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,KAAK,EAAG,YAAqB,CAAA;AAE1C;;;GAGG;AACH,wBAAgB,cAAc,CAAC,SAAS,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAmChF"}

package/dist/utils/test-helpers.js

@@ -192,3 +192,43 @@ export const TEST_IDS = {
  * Use this instead of new Date() in tests to avoid snapshot drift.
  */
 export const TODAY = '2025-08-17';
+/**
+ * Creates a mock CurrentUser with all required properties and sensible defaults.
+ * Pass only the properties you want to override for your specific test.
+ */
+export function createMockUser(overrides = {}) {
+    return {
+        id: TEST_IDS.USER_ID,
+        email: 'test@example.com',
+        fullName: 'Test User',
+        businessAccountId: null,
+        isPremium: false,
+        dateFormat: 0,
+        timeFormat: 0,
+        weeklyGoal: 5,
+        dailyGoal: 5,
+        completedCount: 0,
+        completedToday: 0,
+        daysOff: [],
+        inboxProjectId: TEST_IDS.PROJECT_INBOX,
+        karma: 0,
+        karmaTrend: 'up',
+        lang: 'en',
+        nextWeek: 1,
+        startDay: 1,
+        startPage: 'today',
+        weekendStartDay: 6,
+        tzInfo: {
+            timezone: 'UTC',
+            gmtString: '+00:00',
+            hours: 0,
+            minutes: 0,
+            isDst: 0,
+        },
+        avatarBig: null,
+        avatarMedium: null,
+        avatarS640: null,
+        avatarSmall: null,
+        ...overrides,
+    };
+}

package/package.json

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