@doist/todoist-ai 4.9.4 → 4.10.0

package/README.md

@@ -74,10 +74,17 @@ Then enable the server in Cursor settings if prompted.
 
 #### Claude Code (CLI)
 
+Firstly configure Claude so it has a new MCP available using this command:
+
 ```bash
 claude mcp add --transport http todoist https://ai.todoist.net/mcp
 ```
 
+Then launch `claude`, execute `/mcp`, then select the `todoist` MCP server.
+
+This will take you through a wizard to authenticate using your browser with Todoist. Once complete you will be able to use todoist in `claude`.
+
+
 #### Visual Studio Code
 
 1. Open Command Palette → MCP: Add Server
@@ -116,6 +123,10 @@ For our design philosophy, guidelines, and development patterns, see [docs/tool-
 
 For a complete list of available tools, see the [src/tools](src/tools) directory.
 
+#### OpenAI MCP Compatibility
+
+This server includes `search` and `fetch` tools that follow the [OpenAI MCP specification](https://platform.openai.com/docs/mcp), enabling seamless integration with OpenAI's MCP protocol. These tools return JSON-encoded results optimized for OpenAI's requirements while maintaining compatibility with the broader MCP ecosystem.
+
 ## Dependencies
 
 -   MCP server using the official [@modelcontextprotocol/sdk](https://github.com/modelcontextprotocol/typescript-sdk?tab=readme-ov-file#installation)

package/dist/index.d.ts

@@ -5,6 +5,7 @@ import { addSections } from './tools/add-sections.js';
 import { addTasks } from './tools/add-tasks.js';
 import { completeTasks } from './tools/complete-tasks.js';
 import { deleteObject } from './tools/delete-object.js';
+import { fetch } from './tools/fetch.js';
 import { findComments } from './tools/find-comments.js';
 import { findCompletedTasks } from './tools/find-completed-tasks.js';
 import { findProjectCollaborators } from './tools/find-project-collaborators.js';
@@ -14,6 +15,7 @@ import { findTasks } from './tools/find-tasks.js';
 import { findTasksByDate } from './tools/find-tasks-by-date.js';
 import { getOverview } from './tools/get-overview.js';
 import { manageAssignments } from './tools/manage-assignments.js';
+import { search } from './tools/search.js';
 import { updateComments } from './tools/update-comments.js';
 import { updateProjects } from './tools/update-projects.js';
 import { updateSections } from './tools/update-sections.js';
@@ -673,8 +675,8 @@ declare const tools: {
         };
         execute(args: {
             limit: number;
-            cursor?: string | undefined;
             search?: string | undefined;
+            cursor?: string | undefined;
         }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
             content: {
                 type: "text";
@@ -696,8 +698,8 @@ declare const tools: {
                 hasMore: boolean;
                 appliedFilters: {
                     limit: number;
-                    cursor?: string | undefined;
                     search?: string | undefined;
+                    cursor?: string | undefined;
                 };
             };
         } | {
@@ -1257,7 +1259,39 @@ declare const tools: {
             structuredContent?: undefined;
         }>;
     };
+    search: {
+        name: "search";
+        description: string;
+        parameters: {
+            query: import("zod").ZodString;
+        };
+        execute(args: {
+            query: string;
+        }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: boolean;
+        }>;
+    };
+    fetch: {
+        name: "fetch";
+        description: string;
+        parameters: {
+            id: import("zod").ZodString;
+        };
+        execute(args: {
+            id: string;
+        }, client: import("@doist/todoist-api-typescript").TodoistApi): Promise<{
+            content: {
+                type: "text";
+                text: string;
+            }[];
+            isError?: boolean;
+        }>;
+    };
 };
 export { tools, getMcpServer };
-export { addTasks, completeTasks, updateTasks, findTasks, findTasksByDate, findCompletedTasks, addProjects, updateProjects, findProjects, addSections, updateSections, findSections, addComments, updateComments, findComments, getOverview, deleteObject, userInfo, findProjectCollaborators, manageAssignments, };
+export { addTasks, completeTasks, updateTasks, findTasks, findTasksByDate, findCompletedTasks, addProjects, updateProjects, findProjects, addSections, updateSections, findSections, addComments, updateComments, findComments, getOverview, deleteObject, userInfo, findProjectCollaborators, manageAssignments, search, fetch, };
 //# sourceMappingURL=index.d.ts.map

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/index.js

@@ -10,6 +10,7 @@ import { addTasks } from './tools/add-tasks.js';
 import { completeTasks } from './tools/complete-tasks.js';
 // General tools
 import { deleteObject } from './tools/delete-object.js';
+import { fetch } from './tools/fetch.js';
 import { findComments } from './tools/find-comments.js';
 import { findCompletedTasks } from './tools/find-completed-tasks.js';
 // Assignment and collaboration tools
@@ -20,6 +21,7 @@ import { findTasks } from './tools/find-tasks.js';
 import { findTasksByDate } from './tools/find-tasks-by-date.js';
 import { getOverview } from './tools/get-overview.js';
 import { manageAssignments } from './tools/manage-assignments.js';
+import { search } from './tools/search.js';
 import { updateComments } from './tools/update-comments.js';
 import { updateProjects } from './tools/update-projects.js';
 import { updateSections } from './tools/update-sections.js';
@@ -52,6 +54,9 @@ const tools = {
     // Assignment and collaboration tools
     findProjectCollaborators,
     manageAssignments,
+    // OpenAI MCP tools
+    search,
+    fetch,
 };
 export { tools, getMcpServer };
 export { 
@@ -66,4 +71,6 @@ addComments, updateComments, findComments,
 // General tools
 getOverview, deleteObject, userInfo, 
 // Assignment and collaboration tools
-findProjectCollaborators, manageAssignments, };
+findProjectCollaborators, manageAssignments, 
+// OpenAI MCP tools
+search, fetch, };

package/dist/mcp-helpers.d.ts

@@ -31,6 +31,13 @@ declare function getToolOutput<StructuredContent extends Record<string, unknown>
     })[];
     structuredContent?: undefined;
 };
+declare function getErrorOutput(error: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+};
 /**
  * Register a Todoist tool in an MCP server.
  * @param tool - The tool to register.
@@ -38,5 +45,5 @@ declare function getToolOutput<StructuredContent extends Record<string, unknown>
  * @param client - The Todoist API client to use to execute the tool.
  */
 declare function registerTool<Params extends z.ZodRawShape>(tool: TodoistTool<Params>, server: McpServer, client: TodoistApi): void;
-export { registerTool, getToolOutput };
+export { registerTool, getErrorOutput, getToolOutput };
 //# sourceMappingURL=mcp-helpers.d.ts.map

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

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

package/dist/mcp-helpers.js

@@ -68,4 +68,4 @@ function registerTool(tool, server, client) {
     };
     server.tool(tool.name, tool.description, tool.parameters, cb);
 }
-export { registerTool, getToolOutput };
+export { registerTool, getErrorOutput, getToolOutput };

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

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAwFnE;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,aA8C5F;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../src/mcp-server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AA0FnE;;;;;GAKG;AACH,iBAAS,YAAY,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,aAkD5F;AAED,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/mcp-server.js

@@ -7,6 +7,7 @@ import { addSections } from './tools/add-sections.js';
 import { addTasks } from './tools/add-tasks.js';
 import { completeTasks } from './tools/complete-tasks.js';
 import { deleteObject } from './tools/delete-object.js';
+import { fetch } from './tools/fetch.js';
 import { findComments } from './tools/find-comments.js';
 import { findCompletedTasks } from './tools/find-completed-tasks.js';
 import { findProjectCollaborators } from './tools/find-project-collaborators.js';
@@ -16,6 +17,7 @@ import { findTasks } from './tools/find-tasks.js';
 import { findTasksByDate } from './tools/find-tasks-by-date.js';
 import { getOverview } from './tools/get-overview.js';
 import { manageAssignments } from './tools/manage-assignments.js';
+import { search } from './tools/search.js';
 import { updateComments } from './tools/update-comments.js';
 import { updateProjects } from './tools/update-projects.js';
 import { updateSections } from './tools/update-sections.js';
@@ -125,6 +127,9 @@ function getMcpServer({ todoistApiKey, baseUrl }) {
     // Assignment and collaboration tools
     registerTool(findProjectCollaborators, server, todoist);
     registerTool(manageAssignments, server, todoist);
+    // OpenAI MCP tools
+    registerTool(search, server, todoist);
+    registerTool(fetch, server, todoist);
     return server;
 }
 export { getMcpServer };

package/dist/tool-helpers.d.ts

@@ -89,5 +89,12 @@ declare function getTasksByFilter({ client, query, limit, cursor, }: {
     }[];
     nextCursor: string | null;
 }>;
-export { getTasksByFilter, mapTask, mapProject };
+/**
+ * Build a Todoist URL for a task or project.
+ * @param type - The type of object ('task' or 'project')
+ * @param id - The ID of the object
+ * @returns The URL string
+ */
+declare function buildTodoistUrl(type: 'task' | 'project', id: string): string;
+export { getTasksByFilter, mapTask, mapProject, buildTodoistUrl };
 //# sourceMappingURL=tool-helpers.d.ts.map

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,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"}
+{"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;;;;;;;;;;;;;;;;;GAkBA;AAED;;;;;GAKG;AACH,iBAAS,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,CAAA"}

package/dist/tool-helpers.js

@@ -105,15 +105,9 @@ const ErrorSchema = z.object({
 });
 async function getTasksByFilter({ client, query, limit, cursor, }) {
     try {
-        const { results, nextCursor } = await client.getTasksByFilter({
-            query,
-            cursor,
-            limit,
-        });
-        return {
-            tasks: results.map(mapTask),
-            nextCursor,
-        };
+        const { results, nextCursor } = await client.getTasksByFilter({ query, cursor, limit });
+        const tasks = results.map(mapTask);
+        return { tasks, nextCursor };
     }
     catch (error) {
         const parsedError = ErrorSchema.safeParse(error);
@@ -127,4 +121,13 @@ async function getTasksByFilter({ client, query, limit, cursor, }) {
         throw new Error(`${responseData.error} (tag: ${responseData.errorTag}, code: ${responseData.errorCode})`);
     }
 }
-export { getTasksByFilter, mapTask, mapProject };
+/**
+ * Build a Todoist URL for a task or project.
+ * @param type - The type of object ('task' or 'project')
+ * @param id - The ID of the object
+ * @returns The URL string
+ */
+function buildTodoistUrl(type, id) {
+    return `https://app.todoist.com/app/${type}/${id}`;
+}
+export { getTasksByFilter, mapTask, mapProject, buildTodoistUrl };

package/dist/tools/__tests__/fetch.test.d.ts

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

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

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

package/dist/tools/__tests__/fetch.test.js

@@ -0,0 +1,275 @@
+import { jest } from '@jest/globals';
+import { createMockProject, createMockTask, TEST_IDS } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { fetch } from '../fetch.js';
+// Mock the Todoist API
+const mockTodoistApi = {
+    getTask: jest.fn(),
+    getProject: jest.fn(),
+};
+const { FETCH } = ToolNames;
+describe(`${FETCH} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('fetching tasks', () => {
+        it('should fetch a task by composite ID and return full content', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Important meeting with team',
+                description: 'Discuss project roadmap and timeline',
+                labels: ['work', 'urgent'],
+                priority: 2,
+                projectId: TEST_IDS.PROJECT_WORK,
+                sectionId: TEST_IDS.SECTION_1,
+                due: {
+                    date: '2025-10-15',
+                    isRecurring: false,
+                    datetime: null,
+                    string: '2025-10-15',
+                    timezone: null,
+                    lang: 'en',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getTask).toHaveBeenCalledWith(TEST_IDS.TASK_1);
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toEqual({
+                id: `task:${TEST_IDS.TASK_1}`,
+                title: 'Important meeting with team',
+                text: 'Important meeting with team\n\nDescription: Discuss project roadmap and timeline\nDue: 2025-10-15\nLabels: work, urgent',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
+                metadata: {
+                    priority: 2,
+                    projectId: TEST_IDS.PROJECT_WORK,
+                    sectionId: TEST_IDS.SECTION_1,
+                    parentId: null,
+                    recurring: false,
+                    duration: null,
+                    responsibleUid: null,
+                    assignedByUid: null,
+                },
+            });
+        });
+        it('should fetch a task without optional fields', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_2,
+                content: 'Simple task',
+                description: '',
+                labels: [],
+                due: null,
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_2}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.title).toBe('Simple task');
+            expect(jsonResponse.text).toBe('Simple task');
+            expect(jsonResponse.metadata).toEqual({
+                priority: 1,
+                projectId: TEST_IDS.PROJECT_TEST,
+                sectionId: null,
+                parentId: null,
+                recurring: false,
+                duration: null,
+                responsibleUid: null,
+                assignedByUid: null,
+            });
+        });
+        it('should handle tasks with recurring due dates', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_3,
+                content: 'Weekly meeting',
+                due: {
+                    date: '2025-10-15',
+                    isRecurring: true,
+                    datetime: null,
+                    string: 'every monday',
+                    timezone: null,
+                    lang: 'en',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_3}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.recurring).toBe('every monday');
+        });
+        it('should handle tasks with duration', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Task with duration',
+                duration: {
+                    amount: 90,
+                    unit: 'minute',
+                },
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.duration).toBe('1h30m');
+        });
+        it('should handle tasks with assignments', async () => {
+            const mockTask = createMockTask({
+                id: TEST_IDS.TASK_1,
+                content: 'Assigned task',
+                responsibleUid: 'user-123',
+                assignedByUid: 'user-456',
+            });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.responsibleUid).toBe('user-123');
+            expect(jsonResponse.metadata.assignedByUid).toBe('user-456');
+        });
+    });
+    describe('fetching projects', () => {
+        it('should fetch a project by composite ID and return full content', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_WORK,
+                name: 'Work Project',
+                color: 'blue',
+                isFavorite: true,
+                isShared: true,
+                viewStyle: 'board',
+                parentId: null,
+                inboxProject: false,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
+            // Verify API was called correctly
+            expect(mockTodoistApi.getProject).toHaveBeenCalledWith(TEST_IDS.PROJECT_WORK);
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Work Project',
+                text: 'Work Project\n\nShared project\nFavorite: Yes',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+                metadata: {
+                    color: 'blue',
+                    isFavorite: true,
+                    isShared: true,
+                    parentId: null,
+                    inboxProject: false,
+                    viewStyle: 'board',
+                },
+            });
+        });
+        it('should fetch a project without optional flags', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_TEST,
+                name: 'Simple Project',
+                isFavorite: false,
+                isShared: false,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_TEST}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.title).toBe('Simple Project');
+            expect(jsonResponse.text).toBe('Simple Project');
+            expect(jsonResponse.metadata.isFavorite).toBe(false);
+            expect(jsonResponse.metadata.isShared).toBe(false);
+        });
+        it('should fetch inbox project', async () => {
+            const mockProject = createMockProject({
+                id: TEST_IDS.PROJECT_INBOX,
+                name: 'Inbox',
+                inboxProject: true,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_INBOX}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.inboxProject).toBe(true);
+        });
+        it('should fetch project with parent ID', async () => {
+            const mockProject = createMockProject({
+                id: 'sub-project-id',
+                name: 'Sub Project',
+                parentId: TEST_IDS.PROJECT_WORK,
+            });
+            mockTodoistApi.getProject.mockResolvedValue(mockProject);
+            const result = await fetch.execute({ id: 'project:sub-project-id' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.metadata.parentId).toBe(TEST_IDS.PROJECT_WORK);
+        });
+    });
+    describe('error handling', () => {
+        it('should return error response for invalid ID format (missing colon)', async () => {
+            const result = await fetch.execute({ id: 'invalid-id' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid ID format (missing type)', async () => {
+            const result = await fetch.execute({ id: ':8485093748' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid ID format (missing object ID)', async () => {
+            const result = await fetch.execute({ id: 'task:' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for invalid type', async () => {
+            const result = await fetch.execute({ id: 'section:123' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toContain('Invalid ID format');
+        });
+        it('should return error response for task fetch failure', async () => {
+            mockTodoistApi.getTask.mockRejectedValue(new Error('Task not found'));
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Task not found');
+        });
+        it('should return error response for project fetch failure', async () => {
+            mockTodoistApi.getProject.mockRejectedValue(new Error('Project not found'));
+            const result = await fetch.execute({ id: `project:${TEST_IDS.PROJECT_WORK}` }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Project not found');
+        });
+    });
+    describe('OpenAI MCP spec compliance', () => {
+        it('should return exactly one content item with type "text"', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+        });
+        it('should return valid JSON string in text field', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
+        });
+        it('should include all required fields (id, title, text, url)', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('id');
+            expect(jsonResponse).toHaveProperty('title');
+            expect(jsonResponse).toHaveProperty('text');
+            expect(jsonResponse).toHaveProperty('url');
+            expect(typeof jsonResponse.id).toBe('string');
+            expect(typeof jsonResponse.title).toBe('string');
+            expect(typeof jsonResponse.text).toBe('string');
+            expect(typeof jsonResponse.url).toBe('string');
+        });
+        it('should include optional metadata field', async () => {
+            const mockTask = createMockTask({ id: TEST_IDS.TASK_1, content: 'Test' });
+            mockTodoistApi.getTask.mockResolvedValue(mockTask);
+            const result = await fetch.execute({ id: `task:${TEST_IDS.TASK_1}` }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('metadata');
+            expect(typeof jsonResponse.metadata).toBe('object');
+        });
+    });
+});

package/dist/tools/__tests__/search.test.d.ts

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

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

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

package/dist/tools/__tests__/search.test.js

@@ -0,0 +1,208 @@
+import { jest } from '@jest/globals';
+import { getTasksByFilter } from '../../tool-helpers.js';
+import { createMappedTask, createMockApiResponse, createMockProject, TEST_IDS, } from '../../utils/test-helpers.js';
+import { ToolNames } from '../../utils/tool-names.js';
+import { search } from '../search.js';
+jest.mock('../../tool-helpers', () => {
+    const actual = jest.requireActual('../../tool-helpers');
+    return {
+        getTasksByFilter: jest.fn(),
+        buildTodoistUrl: actual.buildTodoistUrl,
+    };
+});
+const { SEARCH } = ToolNames;
+const mockGetTasksByFilter = getTasksByFilter;
+// Mock the Todoist API
+const mockTodoistApi = {
+    getProjects: jest.fn(),
+};
+describe(`${SEARCH} tool`, () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('searching tasks and projects', () => {
+        it('should search both tasks and projects and return combined results', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Important meeting task',
+                }),
+                createMappedTask({
+                    id: TEST_IDS.TASK_2,
+                    content: 'Another important item',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work Project',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Test Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'important' }, mockTodoistApi);
+            // Verify both API calls were made
+            expect(mockGetTasksByFilter).toHaveBeenCalledWith({
+                client: mockTodoistApi,
+                query: 'search: important',
+                limit: 100, // TASKS_MAX
+                cursor: undefined,
+            });
+            expect(mockTodoistApi.getProjects).toHaveBeenCalledWith({
+                limit: 100, // PROJECTS_MAX
+            });
+            // Verify result structure
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+            // Parse the JSON response
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse).toHaveProperty('results');
+            expect(jsonResponse.results).toHaveLength(3); // 2 tasks + 1 project matching "important"
+            // Verify task results
+            expect(jsonResponse.results[0]).toEqual({
+                id: `task:${TEST_IDS.TASK_1}`,
+                title: 'Important meeting task',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_1}`,
+            });
+            expect(jsonResponse.results[1]).toEqual({
+                id: `task:${TEST_IDS.TASK_2}`,
+                title: 'Another important item',
+                url: `https://app.todoist.com/app/task/${TEST_IDS.TASK_2}`,
+            });
+            // Verify project result (only "Important Work Project" matches)
+            expect(jsonResponse.results[2]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Important Work Project',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return only matching tasks when no projects match', async () => {
+            const mockTasks = [
+                createMappedTask({
+                    id: TEST_IDS.TASK_1,
+                    content: 'Unique task content',
+                }),
+            ];
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Work Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'unique' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].id).toBe(`task:${TEST_IDS.TASK_1}`);
+        });
+        it('should return only matching projects when no tasks match', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Special Project Name',
+                }),
+                createMockProject({
+                    id: TEST_IDS.PROJECT_TEST,
+                    name: 'Another Project',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'special' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0]).toEqual({
+                id: `project:${TEST_IDS.PROJECT_WORK}`,
+                title: 'Special Project Name',
+                url: `https://app.todoist.com/app/project/${TEST_IDS.PROJECT_WORK}`,
+            });
+        });
+        it('should return empty results when nothing matches', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'nonexistent' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(0);
+        });
+        it('should perform case-insensitive project filtering', async () => {
+            const mockProjects = [
+                createMockProject({
+                    id: TEST_IDS.PROJECT_WORK,
+                    name: 'Important Work',
+                }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'IMPORTANT' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(1);
+            expect(jsonResponse.results[0].title).toBe('Important Work');
+        });
+        it('should handle partial matches in project names', async () => {
+            const mockProjects = [
+                createMockProject({ id: 'project-1', name: 'Development Tasks' }),
+                createMockProject({ id: 'project-2', name: 'Developer Resources' }),
+                createMockProject({ id: 'project-3', name: 'Marketing' }),
+            ];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'develop' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            expect(jsonResponse.results).toHaveLength(2);
+            expect(jsonResponse.results[0].title).toBe('Development Tasks');
+            expect(jsonResponse.results[1].title).toBe('Developer Resources');
+        });
+    });
+    describe('error handling', () => {
+        it('should return error response for task search failure', async () => {
+            mockGetTasksByFilter.mockRejectedValue(new Error('Task search failed'));
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Task search failed');
+        });
+        it('should return error response for project search failure', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockRejectedValue(new Error('Project search failed'));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.isError).toBe(true);
+            expect(result.content[0]?.text).toBe('Project search failed');
+        });
+    });
+    describe('OpenAI MCP spec compliance', () => {
+        it('should return exactly one content item with type "text"', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(result.content).toHaveLength(1);
+            expect(result.content[0]?.type).toBe('text');
+        });
+        it('should return valid JSON string in text field', async () => {
+            mockGetTasksByFilter.mockResolvedValue({ tasks: [], nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse([]));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            expect(() => JSON.parse(result.content[0]?.text ?? '{}')).not.toThrow();
+        });
+        it('should include required fields (id, title, url) in each result', async () => {
+            const mockTasks = [createMappedTask({ id: TEST_IDS.TASK_1, content: 'Test' })];
+            const mockProjects = [createMockProject({ id: TEST_IDS.PROJECT_WORK, name: 'Test' })];
+            mockGetTasksByFilter.mockResolvedValue({ tasks: mockTasks, nextCursor: null });
+            mockTodoistApi.getProjects.mockResolvedValue(createMockApiResponse(mockProjects));
+            const result = await search.execute({ query: 'test' }, mockTodoistApi);
+            const jsonResponse = JSON.parse(result.content[0]?.text ?? '{}');
+            for (const item of jsonResponse.results) {
+                expect(item).toHaveProperty('id');
+                expect(item).toHaveProperty('title');
+                expect(item).toHaveProperty('url');
+                expect(typeof item.id).toBe('string');
+                expect(typeof item.title).toBe('string');
+                expect(typeof item.url).toBe('string');
+            }
+        });
+    });
+});

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/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.4",
+    "version": "4.10.0",
     "type": "module",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",