remove_shared_labels

Remove shared labels from Todoist tasks to clean up task organization and maintain label clarity across projects.

Instructions

Remove a shared label in Todoist

Input Schema

TableJSON Schema

Name	Required	Description	Default
`items`	Yes

Implementation Reference

src/tools/labels.ts:100-109 (registration)
Registration of the 'remove_shared_labels' tool. Configures it as a batch API handler that sends POST requests to '/labels/shared/remove' with label names, using mode 'delete' but without idField, resulting in direct POST of name payload.
```
createBatchApiHandler({
    name: 'remove_shared_labels',
    description: 'Remove a shared label in Todoist',
    itemSchema: {
        name: z.string(),
    },
    method: 'POST',
    path: '/labels/shared/remove',
    mode: 'delete',
});
```
src/tools/labels.ts:103-105 (schema)
Zod schema definition for input items: an array of objects each containing a 'name' string field.
```
itemSchema: {
    name: z.string(),
},
```

src/utils/handlers.ts:201-353 (handler)

Handler function generated by createBatchApiHandler that executes the tool: processes batch of label names, POSTs each to Todoist API endpoint '/labels/shared/remove', collects success/failure results with summary.

const handler = async (args: z.infer<typeof batchSchema>): Promise<any> => {
    const { items } = args;

    // For modes other than create, check if name lookup is needed
    let allItems: any[] = [];

    const needsNameLookup =
        options.mode !== 'create' &&
        options.nameField &&
        options.findByName &&
        items.some(item => item[options.nameField!] && !item[options.idField!]);

    if (needsNameLookup) {
        // Determine the base path for fetching all items
        // Example: /tasks from /tasks/{id}
        const lookupPath =
            options.basePath || (options.path ? options.path.split('/{')[0] : '');
        allItems = await todoistApi.get(lookupPath, {});
    }

    const results = await Promise.all(
        items.map(async item => {
            if (options.validateItem) {
                const validation = options.validateItem(item);

                if (!validation.valid) {
                    return {
                        success: false,
                        error: validation.error || 'Validation failed',
                        item,
                    };
                }
            }

            try {
                let finalPath = '';
                const apiParams = { ...item };

                // For modes where need id
                if (options.mode !== 'create' && options.idField) {
                    let itemId = item[options.idField];
                    let matchedName = null;
                    let matchedContent = null;

                    // If no ID but name is provided, search by name
                    if (!itemId && item[options.nameField!] && options.findByName) {
                        const searchName = item[options.nameField!];
                        const matchedItem = options.findByName(searchName, allItems);

                        if (!matchedItem) {
                            return {
                                success: false,
                                error: `Item not found with name: ${searchName}`,
                                item,
                            };
                        }

                        itemId = matchedItem.id;
                        matchedName = searchName;
                        matchedContent = matchedItem.content;
                    }

                    if (!itemId) {
                        return {
                            success: false,
                            error: `Either ${options.idField} or ${options.nameField} must be provided`,
                            item,
                        };
                    }

                    // Apply security validation to itemId before using in path
                    const safeItemId = validatePathParameter(itemId, options.idField || 'id');

                    if (options.basePath && options.pathSuffix) {
                        finalPath = `${options.basePath}${options.pathSuffix.replace('{id}', safeItemId)}`;
                    } else if (options.path) {
                        finalPath = options.path.replace('{id}', safeItemId);
                    }

                    delete apiParams[options.idField];
                    if (options.nameField) {
                        delete apiParams[options.nameField];
                    }

                    let result;
                    switch (options.method) {
                        case 'GET':
                            result = await todoistApi.get(finalPath, apiParams);
                            break;
                        case 'POST':
                            result = await todoistApi.post(finalPath, apiParams);
                            break;
                        case 'DELETE':
                            result = await todoistApi.delete(finalPath);
                            break;
                    }

                    const response: any = {
                        success: true,
                        id: itemId,
                        result,
                    };

                    if (matchedName) {
                        response.found_by_name = matchedName;
                        response.matched_content = matchedContent;
                    }

                    return response;
                }
                // Create mode
                else {
                    finalPath = options.path || options.basePath || '';

                    let result;
                    switch (options.method) {
                        case 'GET':
                            result = await todoistApi.get(finalPath, apiParams);
                            break;
                        case 'POST':
                            result = await todoistApi.post(finalPath, apiParams);
                            break;
                        case 'DELETE':
                            result = await todoistApi.delete(finalPath);
                            break;
                    }

                    return {
                        success: true,
                        created_item: result,
                    };
                }
            } catch (error) {
                return {
                    success: false,
                    error: error instanceof Error ? error.message : String(error),
                    item,
                };
            }
        })
    );

    const successCount = results.filter(r => r.success).length;
    return {
        success: successCount === items.length,
        summary: {
            total: items.length,
            succeeded: successCount,
            failed: items.length - successCount,
        },
        results,
    };
};

src/utils/handlers.ts:40-77 (helper)

Utility that registers the tool with the MCP server by calling server.tool, wraps the specific handler with standardized MCP response format and error handling.

export function createHandler<T extends z.ZodRawShape>(
    name: string,
    description: string,
    paramsSchema: T,
    handler: (args: HandlerArgs<T>) => Promise<any>
): void {
    const mcpToolCallback = async (args: HandlerArgs<T>): Promise<CallToolResult> => {
        try {
            const result = await handler(args);

            return {
                content: [
                    {
                        type: 'text',
                        text: JSON.stringify(result ?? null, null, 2).trim(),
                    },
                ],
            };
        } catch (error) {
            const errorMessage = error instanceof Error ? error.message : String(error);

            console.error(`Error in tool ${name}:`, error);

            return {
                isError: true,
                content: [
                    {
                        type: 'text',
                        text: `Error executing tool '${name}': ${errorMessage}`,
                    },
                ],
            };
        }
    };

    // Crazy cast, if you can do it better, please, let me knows
    server.tool(name, description, paramsSchema, mcpToolCallback as unknown as ToolCallback<T>);
}

todoist-mcp