@taazkareem/clickup-mcp-server 0.6.3 → 0.6.5

package/README.md

@@ -6,7 +6,7 @@
 
 A Model Context Protocol (MCP) server for integrating ClickUp tasks with AI applications. This server allows AI agents to interact with ClickUp tasks, spaces, lists, and folders through a standardized protocol.
 
-> 🚧 **Status Update:** Rolling out v0.6.3 will add Global Task Lookup with smart disambiguation, Start Date Support for tasks with natural language expressions, Complete Tag Support including natural language tag color commands, Subtasks Support, Custom ID Support, and Logging Fixes
+> 🚧 **Status Update:** Rolling out v0.6.4 will add Global Task Lookup with smart disambiguation, Start Date Support for tasks with natural language expressions, Complete Tag Support including natural language tag color commands, Subtasks Support, Custom ID Support, and Logging Fixes
 
 ## Setup
 

package/build/config.js

@@ -43,7 +43,7 @@ export const parseLogLevel = (levelStr) => {
         case 'WARN': return LogLevel.WARN;
         case 'ERROR': return LogLevel.ERROR;
         default:
-            console.error(`Invalid LOG_LEVEL: ${levelStr}, defaulting to ERROR`);
+            // Don't use console.error as it interferes with JSON-RPC communication
             return LogLevel.ERROR;
     }
 };
@@ -54,8 +54,7 @@ const configuration = {
     enableSponsorMessage: process.env.ENABLE_SPONSOR_MESSAGE !== 'false',
     logLevel: parseLogLevel(envArgs.logLevel || process.env.LOG_LEVEL)
 };
-// Log the configured log level (but only to console to avoid circular dependency)
-console.debug(`Log level set to: ${LogLevel[configuration.logLevel]}`);
+// Don't log to console as it interferes with JSON-RPC communication
 // Validate only the required variables are present
 const requiredVars = ['clickupApiKey', 'clickupTeamId'];
 const missingEnvVars = requiredVars

package/build/index.js

@@ -23,43 +23,27 @@
  */
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { configureServer, server } from "./server.js";
-import { info, error, warn } from "./logger.js";
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-/**
- * Check if another instance of the server is already running
- * @returns Boolean indicating if this is the only instance
- */
-async function checkSingleInstance() {
-    try {
-        const { stdout } = await execAsync(`ps aux | grep "node.*clickup-mcp-server" | grep -v grep | wc -l`);
-        const instanceCount = parseInt(stdout.trim(), 10);
-        // If there's more than one instance (including this one), warn and exit
-        if (instanceCount > 1) {
-            error(`Multiple server instances detected (${instanceCount}). This may cause issues.`);
-            info("Use 'pkill -9 -f clickup-mcp-server' to kill all instances before starting a new one.");
-            return false;
-        }
-        return true;
-    }
-    catch (err) {
-        error("Failed to check for other running instances", err);
-        // Continue execution even if check fails
-        return true;
-    }
-}
+import { info, error } from "./logger.js";
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Get directory name for module paths
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Handle uncaught exceptions
+process.on('uncaughtException', (err) => {
+    error("Uncaught Exception", { message: err.message, stack: err.stack });
+    process.exit(1);
+});
+// Handle unhandled promise rejections
+process.on('unhandledRejection', (reason, promise) => {
+    error("Unhandled Rejection", { reason });
+    process.exit(1);
+});
 /**
  * Application entry point that configures and starts the MCP server.
  */
 async function main() {
     try {
         info("Starting ClickUp MCP Server...");
-        // Check if we're the only instance
-        const isSingleInstance = await checkSingleInstance();
-        if (!isSingleInstance) {
-            warn("Continuing startup despite multiple instances detected");
-        }
         // Log essential information about the environment
         info("Server environment", {
             pid: process.pid,
@@ -77,11 +61,11 @@ async function main() {
         info("Server startup complete - ready to handle requests");
     }
     catch (err) {
-        error("Error during server startup", err);
+        error("Error during server startup", { message: err.message, stack: err.stack });
         process.exit(1);
     }
 }
 main().catch((err) => {
-    error("Unhandled server error", err);
+    error("Unhandled server error", { message: err.message, stack: err.stack });
     process.exit(1);
 });

package/build/logger.js

@@ -5,7 +5,7 @@
  * Logger module for MCP Server
  *
  * This module provides logging functionality for the server,
- * writing logs to both the console and a log file in the build folder.
+ * writing logs to only the log file to avoid interfering with JSON-RPC.
  */
 import { createWriteStream } from 'fs';
 import { join, dirname } from 'path';
@@ -18,7 +18,8 @@ const pid = process.pid;
 // Create a write stream for logging - use a fixed filename in the build directory
 const logFileName = 'server.log';
 const logStream = createWriteStream(join(__dirname, logFileName), { flags: 'w' });
-console.error(`Logging to ${join(__dirname, logFileName)}`);
+// Write init message to log file only
+logStream.write(`Logging initialized to ${join(__dirname, logFileName)}\n`);
 // Use the configured log level from config.ts
 const configuredLevel = config.logLevel;
 // Re-export LogLevel enum
@@ -32,7 +33,7 @@ export function isLevelEnabled(level) {
     return level >= configuredLevel;
 }
 /**
- * Log function that writes to both console and file
+ * Log function that writes only to file to avoid interfering with JSON-RPC
  * @param level Log level (trace, debug, info, warn, error)
  * @param message Message to log
  * @param data Optional data to include in log
@@ -74,9 +75,7 @@ export function log(level, message, data) {
             logMessage += '\n' + JSON.stringify(data, null, 2);
         }
     }
-    // When using stdio transport, log to stderr which is captured by host application
-    console.error(logMessage);
-    // Write to file
+    // Write to file only, not to stderr which would interfere with JSON-RPC
     logStream.write(logMessage + '\n');
 }
 /**

package/build/server.js

@@ -5,12 +5,12 @@
  * MCP Server for ClickUp integration
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { workspaceHierarchyTool, handleGetWorkspaceHierarchy } from "./tools/workspace.js";
 import { createTaskTool, updateTaskTool, moveTaskTool, duplicateTaskTool, getTaskTool, getTasksTool, deleteTaskTool, getTaskCommentsTool, createTaskCommentTool, createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool, attachTaskFileTool, getWorkspaceTasksTool, handleCreateTask, handleUpdateTask, handleMoveTask, handleDuplicateTask, handleGetTasks, handleDeleteTask, handleGetTaskComments, handleCreateTaskComment, handleCreateBulkTasks, handleUpdateBulkTasks, handleMoveBulkTasks, handleDeleteBulkTasks, handleGetTask, handleAttachTaskFile, handleGetWorkspaceTasks } from "./tools/task/index.js";
 import { createListTool, handleCreateList, createListInFolderTool, handleCreateListInFolder, getListTool, handleGetList, updateListTool, handleUpdateList, deleteListTool, handleDeleteList } from "./tools/list.js";
 import { createFolderTool, handleCreateFolder, getFolderTool, handleGetFolder, updateFolderTool, handleUpdateFolder, deleteFolderTool, handleDeleteFolder } from "./tools/folder.js";
-import { getSpaceTagsTool, handleGetSpaceTags, createSpaceTagTool, handleCreateSpaceTag, updateSpaceTagTool, handleUpdateSpaceTag, deleteSpaceTagTool, handleDeleteSpaceTag, addTagToTaskTool, handleAddTagToTask, removeTagFromTaskTool, handleRemoveTagFromTask } from "./tools/tag.js";
+import { getSpaceTagsTool, handleGetSpaceTags, addTagToTaskTool, handleAddTagToTask, removeTagFromTaskTool, handleRemoveTagFromTask } from "./tools/tag.js";
 import { Logger } from "./logger.js";
 import { clickUpServices } from "./services/shared.js";
 // Create a logger instance for server
@@ -19,11 +19,12 @@ const logger = new Logger('Server');
 const { workspace } = clickUpServices;
 export const server = new Server({
     name: "clickup-mcp-server",
-    version: "0.6.3",
+    version: "0.6.5",
 }, {
     capabilities: {
         tools: {},
         prompts: {},
+        resources: {},
     },
 });
 /**
@@ -62,17 +63,19 @@ export function configureServer() {
                 updateFolderTool,
                 deleteFolderTool,
                 getSpaceTagsTool,
-                createSpaceTagTool,
-                updateSpaceTagTool,
-                deleteSpaceTagTool,
                 addTagToTaskTool,
                 removeTagFromTaskTool
             ]
         };
     });
+    // Add handler for resources/list
+    server.setRequestHandler(ListResourcesRequestSchema, async (req) => {
+        logger.debug("Received ListResources request");
+        return { resources: [] };
+    });
     // Register CallTool handler with proper logging
     logger.info("Registering tool handlers", {
-        toolCount: 31,
+        toolCount: 28,
         categories: ["workspace", "task", "list", "folder", "tag"]
     });
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
@@ -136,24 +139,39 @@ export function configureServer() {
                     return handleDeleteFolder(params);
                 case "get_space_tags":
                     return handleGetSpaceTags(params);
-                case "create_space_tag":
-                    return handleCreateSpaceTag(params);
-                case "update_space_tag":
-                    return handleUpdateSpaceTag(params);
-                case "delete_space_tag":
-                    return handleDeleteSpaceTag(params);
                 case "add_tag_to_task":
                     return handleAddTagToTask(params);
                 case "remove_tag_from_task":
                     return handleRemoveTagFromTask(params);
                 default:
                     logger.error(`Unknown tool requested: ${name}`);
-                    throw new Error(`Unknown tool: ${name}`);
+                    const error = new Error(`Unknown tool: ${name}`);
+                    error.name = "UnknownToolError";
+                    throw error;
             }
         }
         catch (err) {
             logger.error(`Error executing tool: ${name}`, err);
-            throw err;
+            // Transform error to a more descriptive JSON-RPC error
+            if (err.name === "UnknownToolError") {
+                throw {
+                    code: -32601,
+                    message: `Method not found: ${name}`
+                };
+            }
+            else if (err.name === "ValidationError") {
+                throw {
+                    code: -32602,
+                    message: `Invalid params for tool ${name}: ${err.message}`
+                };
+            }
+            else {
+                // Generic server error
+                throw {
+                    code: -32000,
+                    message: `Error executing tool ${name}: ${err.message}`
+                };
+            }
         }
     });
     server.setRequestHandler(ListPromptsRequestSchema, async () => {

package/build/services/clickup/bulk.js

@@ -7,15 +7,21 @@
  * Enhanced implementation for bulk operations that leverages the existing single-operation methods.
  * This approach reduces code duplication while offering powerful concurrency management.
  */
-import { ClickUpServiceError, ErrorCode } from './base.js';
-import { processBatch } from '../../utils/concurrency-utils.js';
 import { Logger } from '../../logger.js';
+import { processBatch } from '../../utils/concurrency-utils.js';
+import { ClickUpServiceError, ErrorCode } from './base.js';
+import { clickUpServices } from '../shared.js';
+import { findListIDByName } from '../../tools/list.js';
 // Create logger instance
 const logger = new Logger('BulkService');
 /**
- * Service for handling bulk operations in ClickUp
+ * Service for performing bulk operations in ClickUp
  */
 export class BulkService {
+    /**
+     * Create a new bulk service
+     * @param taskService ClickUp Task Service instance
+     */
     constructor(taskService) {
         this.taskService = taskService;
         logger.info('BulkService initialized');
@@ -54,6 +60,61 @@ export class BulkService {
             throw new ClickUpServiceError(`Failed to create tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { listId, taskCount: tasks.length });
         }
     }
+    /**
+     * Find task by name within a specific list
+     */
+    async findTaskInList(taskName, listName) {
+        try {
+            // First get the list ID using the global lookup utility
+            const listInfo = await findListIDByName(clickUpServices.workspace, listName);
+            if (!listInfo) {
+                throw new ClickUpServiceError(`List "${listName}" not found`, ErrorCode.NOT_FOUND);
+            }
+            logger.info(`List "${listName}" resolved to ID: ${listInfo.id}`);
+            // Get tasks from the list using the resolved ID
+            const taskList = await this.taskService.getTasks(listInfo.id);
+            // Find the task by name - first try exact match
+            let matchingTask = taskList.find(t => t.name === taskName);
+            // If no exact match, try case-insensitive match
+            if (!matchingTask) {
+                matchingTask = taskList.find(t => t.name.toLowerCase() === taskName.toLowerCase());
+                // If still no match, try substring match as a fallback
+                if (!matchingTask) {
+                    matchingTask = taskList.find(t => t.name.toLowerCase().includes(taskName.toLowerCase()) ||
+                        taskName.toLowerCase().includes(t.name.toLowerCase()));
+                }
+            }
+            if (!matchingTask) {
+                throw new ClickUpServiceError(`Task "${taskName}" not found in list "${listName}"`, ErrorCode.NOT_FOUND);
+            }
+            logger.info(`Task "${taskName}" found with ID: ${matchingTask.id}`);
+            return matchingTask.id;
+        }
+        catch (error) {
+            // Enhance the error message
+            if (error instanceof ClickUpServiceError) {
+                throw error;
+            }
+            throw new ClickUpServiceError(`Error finding task "${taskName}" in list "${listName}": ${error instanceof Error ? error.message : String(error)}`, ErrorCode.UNKNOWN);
+        }
+    }
+    /**
+     * Resolve task ID using provided identifiers
+     */
+    async resolveTaskId(task) {
+        const { taskId, taskName, listName, customTaskId } = task;
+        if (taskId) {
+            return taskId;
+        }
+        if (customTaskId) {
+            const resolvedTask = await this.taskService.getTaskByCustomId(customTaskId);
+            return resolvedTask.id;
+        }
+        if (taskName && listName) {
+            return await this.findTaskInList(taskName, listName);
+        }
+        throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
+    }
     /**
      * Update multiple tasks
      * @param tasks Array of tasks to update with their new data
@@ -63,36 +124,10 @@ export class BulkService {
     async updateTasks(tasks, options) {
         logger.info('Starting bulk update operation', { taskCount: tasks.length });
         try {
-            // Extract all task IDs that need validation
-            const taskIds = tasks
-                .map(task => task.taskId)
-                .filter((id) => !!id);
-            // Validate all tasks exist in parallel
-            if (taskIds.length > 0) {
-                await this.taskService.validateTasksExist(taskIds);
-            }
-            // Process updates in batches
             return await processBatch(tasks, async (task) => {
                 const { taskId, taskName, listName, customTaskId, ...updateData } = task;
-                if (taskId) {
-                    return await this.taskService.updateTask(taskId, updateData);
-                }
-                else if (customTaskId) {
-                    const resolvedTask = await this.taskService.getTaskByCustomId(customTaskId);
-                    return await this.taskService.updateTask(resolvedTask.id, updateData);
-                }
-                else if (taskName && listName) {
-                    // For tasks identified by name, we need to resolve the ID first
-                    const taskList = await this.taskService.getTasks(listName);
-                    const matchingTask = taskList.find(t => t.name === taskName);
-                    if (!matchingTask) {
-                        throw new ClickUpServiceError(`Task "${taskName}" not found in list "${listName}"`, ErrorCode.NOT_FOUND);
-                    }
-                    return await this.taskService.updateTask(matchingTask.id, updateData);
-                }
-                else {
-                    throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
-                }
+                const resolvedTaskId = await this.resolveTaskId({ taskId, taskName, listName, customTaskId });
+                return await this.taskService.updateTask(resolvedTaskId, updateData);
             }, options);
         }
         catch (error) {
@@ -103,44 +138,31 @@ export class BulkService {
     /**
      * Move multiple tasks to a different list
      * @param tasks Array of tasks to move (each with taskId or taskName + listName)
-     * @param targetListId ID of the destination list
+     * @param targetListId ID of the destination list or list name
      * @param options Optional batch processing settings
      * @returns Array of moved tasks
      */
     async moveTasks(tasks, targetListId, options) {
         logger.info('Starting bulk move operation', { taskCount: tasks.length, targetListId });
         try {
-            // First validate the destination list exists
-            await this.taskService.validateListExists(targetListId);
-            // Extract all task IDs that need validation
-            const taskIds = tasks
-                .map(task => task.taskId)
-                .filter((id) => !!id);
-            // Validate all tasks exist in parallel
-            if (taskIds.length > 0) {
-                await this.taskService.validateTasksExist(taskIds);
+            // Determine if targetListId is actually an ID or a name
+            let resolvedTargetListId = targetListId;
+            // If the targetListId doesn't match the pattern of a list ID (usually just numbers),
+            // assume it's a list name and try to resolve it
+            if (!/^\d+$/.test(targetListId)) {
+                logger.info(`Target list appears to be a name: "${targetListId}", attempting to resolve`);
+                const listInfo = await findListIDByName(clickUpServices.workspace, targetListId);
+                if (!listInfo) {
+                    throw new ClickUpServiceError(`Target list "${targetListId}" not found`, ErrorCode.NOT_FOUND);
+                }
+                resolvedTargetListId = listInfo.id;
+                logger.info(`Resolved target list to ID: ${resolvedTargetListId}`);
             }
-            // Process moves in batches
+            // Validate the destination list exists
+            await this.taskService.validateListExists(resolvedTargetListId);
             return await processBatch(tasks, async (task) => {
-                if (task.taskId) {
-                    return await this.taskService.moveTask(task.taskId, targetListId);
-                }
-                else if (task.customTaskId) {
-                    const resolvedTask = await this.taskService.getTaskByCustomId(task.customTaskId);
-                    return await this.taskService.moveTask(resolvedTask.id, targetListId);
-                }
-                else if (task.taskName && task.listName) {
-                    // For tasks identified by name, we need to resolve the ID first
-                    const taskList = await this.taskService.getTasks(task.listName);
-                    const matchingTask = taskList.find(t => t.name === task.taskName);
-                    if (!matchingTask) {
-                        throw new ClickUpServiceError(`Task "${task.taskName}" not found in list "${task.listName}"`, ErrorCode.NOT_FOUND);
-                    }
-                    return await this.taskService.moveTask(matchingTask.id, targetListId);
-                }
-                else {
-                    throw new ClickUpServiceError('Invalid task identification. Provide either taskId, customTaskId, or both taskName and listName', ErrorCode.INVALID_PARAMETER);
-                }
+                const resolvedTaskId = await this.resolveTaskId(task);
+                return await this.taskService.moveTask(resolvedTaskId, resolvedTargetListId);
             }, options);
         }
         catch (error) {
@@ -149,33 +171,22 @@ export class BulkService {
         }
     }
     /**
-     * Delete multiple tasks efficiently
-     *
-     * @param taskIds Array of task IDs to delete
+     * Delete multiple tasks
+     * @param tasks Array of tasks to delete (each with taskId or taskName + listName)
      * @param options Batch processing options
      * @returns Results containing successful and failed deletions
      */
-    async deleteTasks(taskIds, options) {
-        logger.info(`Deleting ${taskIds.length} tasks`, {
-            batchSize: options?.batchSize,
-            concurrency: options?.concurrency
-        });
+    async deleteTasks(tasks, options) {
+        logger.info('Starting bulk delete operation', { taskCount: tasks.length });
         try {
-            return await processBatch(taskIds, async (taskId, index) => {
-                logger.debug(`Deleting task ${index + 1}/${taskIds.length}`, {
-                    taskId
-                });
-                // Reuse the single-task delete method
-                await this.taskService.deleteTask(taskId);
-                return taskId; // Return the ID for successful deletions
+            return await processBatch(tasks, async (task) => {
+                const resolvedTaskId = await this.resolveTaskId(task);
+                await this.taskService.deleteTask(resolvedTaskId);
             }, options);
         }
         catch (error) {
-            logger.error(`Failed to delete tasks in bulk`, {
-                taskCount: taskIds.length,
-                error: error instanceof Error ? error.message : String(error)
-            });
-            throw new ClickUpServiceError(`Failed to delete tasks in bulk: ${error instanceof Error ? error.message : String(error)}`, error instanceof ClickUpServiceError ? error.code : ErrorCode.UNKNOWN, { taskCount: taskIds.length });
+            logger.error('Bulk delete operation failed', error);
+            throw error;
         }
     }
 }

package/build/services/clickup/task/task-core.js

@@ -276,7 +276,7 @@ export class TaskServiceCore extends BaseClickUpService {
         }
     }
     /**
-     * Move a task to a different list
+     * Move a task to another list
      * @param taskId The ID of the task to move
      * @param destinationListId The ID of the list to move the task to
      * @returns The updated task
@@ -285,70 +285,32 @@ export class TaskServiceCore extends BaseClickUpService {
         const startTime = Date.now();
         this.logOperation('moveTask', { taskId, destinationListId, operation: 'start' });
         try {
-            // First, get both the task and list info in parallel
-            const [task, listResult] = await Promise.all([
+            // First, get task and validate destination list
+            const [sourceTask, _] = await Promise.all([
                 this.validateTaskExists(taskId),
-                this.validateListExists(destinationListId).then(() => this.listService.getList(destinationListId))
+                this.validateListExists(destinationListId)
             ]);
-            const originalTask = task;
-            const destinationList = listResult;
-            // Log parallel request timing
-            const parallelRequestTime = Date.now() - startTime;
-            this.logOperation('moveTask', {
-                taskId,
-                destinationListId,
-                operation: 'parallel_requests_complete',
-                timing: { parallelRequestTime }
-            });
-            const currentStatus = originalTask.status?.status;
-            const availableStatuses = destinationList.statuses?.map(s => s.status) || [];
-            // Enhanced status mapping logic
-            let newStatus = currentStatus;
-            if (currentStatus && availableStatuses.length > 0) {
-                // Only map status if current status isn't available in destination list
-                if (!availableStatuses.includes(currentStatus)) {
-                    // Try to find a similar status
-                    const similarStatus = availableStatuses.find(s => s.toLowerCase().includes(currentStatus.toLowerCase()) ||
-                        currentStatus.toLowerCase().includes(s.toLowerCase()));
-                    // If no similar status found, use the first available status
-                    newStatus = similarStatus || availableStatuses[0];
-                    this.logger.debug('Status mapping', {
-                        original: currentStatus,
-                        mapped: newStatus,
-                        available: availableStatuses
-                    });
-                }
-            }
-            // Make the move request
-            const movedTask = await this.makeRequest(async () => {
-                const response = await this.client.post(`/task/${taskId}`, {
-                    list: destinationListId,
-                    status: newStatus
-                });
-                return response.data;
-            });
-            // Cache the moved task
-            this.validationCache.tasks.set(taskId, {
+            // Extract task data for creating the new task
+            const taskData = this.extractTaskData(sourceTask);
+            // Create the task in the new list
+            const newTask = await this.createTask(destinationListId, taskData);
+            // Delete the original task
+            await this.deleteTask(taskId);
+            // Update the cache
+            this.validationCache.tasks.delete(taskId);
+            this.validationCache.tasks.set(newTask.id, {
                 validatedAt: Date.now(),
-                task: movedTask
+                task: newTask
             });
             const totalTime = Date.now() - startTime;
             this.logOperation('moveTask', {
                 taskId,
                 destinationListId,
                 operation: 'complete',
-                timing: {
-                    totalTime,
-                    parallelRequestTime,
-                    moveOperationTime: totalTime - parallelRequestTime
-                },
-                statusMapping: {
-                    original: currentStatus,
-                    new: newStatus,
-                    wasMapped: currentStatus !== newStatus
-                }
+                timing: { totalTime },
+                newTaskId: newTask.id
             });
-            return movedTask;
+            return newTask;
         }
         catch (error) {
             // Log failure
@@ -356,7 +318,7 @@ export class TaskServiceCore extends BaseClickUpService {
                 taskId,
                 destinationListId,
                 operation: 'failed',
-                error: error.message,
+                error: error instanceof Error ? error.message : String(error),
                 timing: { totalTime: Date.now() - startTime }
             });
             throw this.handleError(error, 'Failed to move task');

package/build/tools/tag.js

@@ -26,15 +26,11 @@ export const getSpaceTagsTool = {
     description: `Purpose: Get all tags available in a ClickUp space.
 
 Valid Usage:
-1. Provide spaceId (preferred if available)
-2. Provide spaceName (will be resolved to a space ID)
+1. Provide spaceId (preferred)
+2. Provide spaceName
 
 Requirements:
-- EITHER spaceId OR spaceName is REQUIRED
-
-Notes:
-- Tags are defined at the space level in ClickUp
-- You need to know the available tags before adding them to tasks`,
+- Space identification: EITHER spaceId OR spaceName REQUIRED`,
     inputSchema: {
         type: "object",
         properties: {
@@ -57,18 +53,15 @@ export const createSpaceTagTool = {
     description: `Purpose: Create a new tag in a ClickUp space.
 
 Valid Usage:
-1. Provide spaceId (preferred if available)
-2. Provide spaceName (will be resolved to a space ID)
+1. Provide spaceId + tagName (preferred)
+2. Provide spaceName + tagName
 
 Requirements:
 - tagName: REQUIRED
-- EITHER spaceId OR spaceName: REQUIRED
+- Space identification: EITHER spaceId OR spaceName REQUIRED
 
 Notes:
-- New tag will be available for all tasks in the space
-- You can specify background and foreground colors in HEX format (e.g., #FF0000)
-- You can also provide a color command (e.g., "blue tag") to automatically generate colors
-- After creating a tag, you can add it to tasks using add_tag_to_task`,
+- Specify colors with HEX values or natural language command`,
     inputSchema: {
         type: "object",
         properties: {