@taazkareem/clickup-mcp-server 0.8.5 → 0.9.1

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

@@ -7,12 +7,20 @@
  * Handles tag operations for ClickUp tasks, including:
  * - Adding tags to a task
  * - Removing tags from a task
+ *
+ * REFACTORED: Now uses composition instead of inheritance.
+ * Only depends on TaskServiceCore for getTask() and base functionality.
  */
-import { TaskServiceComments } from './task-comments.js';
 /**
  * Tags functionality for the TaskService
+ *
+ * This service handles all tag-related operations for ClickUp tasks.
+ * It uses composition to access core functionality instead of inheritance.
  */
-export class TaskServiceTags extends TaskServiceComments {
+export class TaskServiceTags {
+    constructor(core) {
+        this.core = core;
+    }
     /**
      * Add a tag to a task
      *
@@ -21,16 +29,18 @@ export class TaskServiceTags extends TaskServiceComments {
      * @returns Success response
      */
     async addTagToTask(taskId, tagName) {
-        this.logOperation('addTagToTask', { taskId, tagName });
+        this.core.logOperation('addTagToTask', { taskId, tagName });
         try {
             const payload = {
                 tag_name: tagName,
             };
-            await this.client.post(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`, payload);
+            await this.core.makeRequest(async () => {
+                return await this.core.client.post(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`, payload);
+            });
             return true;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to add tag "${tagName}" to task`);
+            throw this.core.handleError(error, `Failed to add tag "${tagName}" to task`);
         }
     }
     /**
@@ -41,13 +51,15 @@ export class TaskServiceTags extends TaskServiceComments {
      * @returns Success response
      */
     async removeTagFromTask(taskId, tagName) {
-        this.logOperation('removeTagFromTask', { taskId, tagName });
+        this.core.logOperation('removeTagFromTask', { taskId, tagName });
         try {
-            await this.client.delete(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`);
+            await this.core.makeRequest(async () => {
+                return await this.core.client.delete(`/task/${taskId}/tag/${encodeURIComponent(tagName)}`);
+            });
             return true;
         }
         catch (error) {
-            throw this.handleError(error, `Failed to remove tag "${tagName}" from task`);
+            throw this.core.handleError(error, `Failed to remove tag "${tagName}" from task`);
         }
     }
     /**
@@ -57,14 +69,14 @@ export class TaskServiceTags extends TaskServiceComments {
      * @returns Array of task tags
      */
     async getTaskTags(taskId) {
-        this.logOperation('getTaskTags', { taskId });
+        this.core.logOperation('getTaskTags', { taskId });
         try {
             // We need to fetch the full task to get its tags
-            const task = await this.getTask(taskId);
+            const task = await this.core.getTask(taskId);
             return task.tags || [];
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to get task tags');
+            throw this.core.handleError(error, 'Failed to get task tags');
         }
     }
     /**
@@ -75,7 +87,7 @@ export class TaskServiceTags extends TaskServiceComments {
      * @returns Success response
      */
     async updateTaskTags(taskId, tagNames) {
-        this.logOperation('updateTaskTags', { taskId, tagNames });
+        this.core.logOperation('updateTaskTags', { taskId, tagNames });
         try {
             // First get existing tags
             const existingTags = await this.getTaskTags(taskId);
@@ -95,7 +107,7 @@ export class TaskServiceTags extends TaskServiceComments {
             return true;
         }
         catch (error) {
-            throw this.handleError(error, 'Failed to update task tags');
+            throw this.core.handleError(error, 'Failed to update task tags');
         }
     }
 }

package/build/sse_server.js

@@ -244,11 +244,11 @@ export function startSSEServer() {
         }
         catch (error) {
             logger.error('Failed to start HTTPS server', {
-                error: error.message,
-                sslKeyPath: configuration.sslKeyPath,
-                sslCertPath: configuration.sslCertPath
+                error: 'An error occurred while starting HTTPS server.',
+                sslKeyPath: 'REDACTED',
+                sslCertPath: 'REDACTED'
             });
-            console.log(`❌ Failed to start HTTPS server: ${error.message}`);
+            console.log(`❌ Failed to start HTTPS server. Please check the server configuration and logs for details.`);
             return null;
         }
     }

package/build/tools/documents.js

@@ -19,7 +19,14 @@ const { document: documentService } = clickUpServices;
  */
 export const createDocumentTool = {
     name: "create_document",
-    description: `Creates a document in a ClickUp space, folder, or list. Requires name, parent info, visibility and create_page flag.`,
+    description: `Creates a document in a ClickUp space, folder, or list. Requires name, parent info, visibility and create_page flag.
+
+Example usage:
+- For list: parent: {"id": "901407953112", "type": 6}
+- For space: parent: {"id": "90141392755", "type": 4}
+- For folder: parent: {"id": "90144231850", "type": 5}
+
+Note: Document creation permissions may vary by ClickUp plan and parent container type.`,
     inputSchema: {
         type: "object",
         properties: {
@@ -32,16 +39,16 @@ export const createDocumentTool = {
                 properties: {
                     id: {
                         type: "string",
-                        description: "ID of the parent container (space, folder, or list)"
+                        description: "ID of the parent container (space, folder, or list). Use actual ID from workspace hierarchy."
                     },
                     type: {
                         type: "number",
                         enum: [4, 5, 6, 7, 12],
-                        description: "Type of the parent container (4=space, 5=folder, 6=list, 7=everything, 12=workspace)"
+                        description: "Type of the parent container: 4=space, 5=folder, 6=list, 7=everything, 12=workspace. Most commonly use 6 for lists."
                     }
                 },
                 required: ["id", "type"],
-                description: "Parent container information"
+                description: "Parent container object with id and type properties. Example: {\"id\": \"901407953112\", \"type\": 6}"
             },
             visibility: {
                 type: "string",

package/build/tools/health.js

@@ -0,0 +1,23 @@
+/**
+ * Simple health‑check tool – returns a tiny JSON payload confirming the server is alive.
+ */
+export const healthCheckTool = {
+    name: "health_check",
+    description: "Returns a simple health status for the MCP server.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    },
+    outputSchema: {
+        type: "object",
+        properties: {
+            status: { type: "string" },
+        },
+        required: ["status"],
+    },
+};
+/** Handler invoked by CallTool when the client requests "health_check" */
+export async function handleHealthCheck() {
+    return { status: "ok" };
+}

package/build/utils/schema-compatibility.js

@@ -0,0 +1,222 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Universal Schema Compatibility for MCP Multi-LLM Support
+ *
+ * This module provides universal schema compatibility that works simultaneously
+ * with Claude, OpenAI, and Gemini clients without requiring client detection.
+ * The approach creates inherently compatible schemas rather than transforming them.
+ */
+/**
+ * Create a universal schema that works across all major LLM clients
+ * This approach uses flexible schema definitions that are inherently compatible
+ * with Claude, OpenAI, and Gemini without requiring client detection
+ */
+export function createUniversalSchema(originalSchema) {
+    if (!originalSchema || typeof originalSchema !== 'object') {
+        return originalSchema;
+    }
+    // Deep clone to avoid mutating original
+    const universalSchema = JSON.parse(JSON.stringify(originalSchema));
+    // Apply universal compatibility transformations
+    transformSchemaForUniversalCompatibility(universalSchema);
+    return universalSchema;
+}
+/**
+ * Transform a schema to be universally compatible with all LLM clients
+ * Uses flexible type definitions and multiple format support
+ */
+function transformSchemaForUniversalCompatibility(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    // Handle type field - make it flexible for all clients
+    if (schema.type) {
+        // Store original type for reference
+        const originalType = schema.type;
+        // For universal compatibility, we use an approach that works with all clients:
+        // 1. Keep the standard lowercase type (works with Claude/OpenAI)
+        // 2. Add format hints that Gemini can understand
+        // 3. Use flexible validation that doesn't break any client
+        switch (originalType.toLowerCase()) {
+            case 'string':
+                schema.type = 'string';
+                // Add format hints for better compatibility
+                if (!schema.format) {
+                    schema.format = 'text';
+                }
+                break;
+            case 'number':
+                schema.type = 'number';
+                break;
+            case 'integer':
+                schema.type = 'integer';
+                break;
+            case 'boolean':
+                schema.type = 'boolean';
+                break;
+            case 'array':
+                schema.type = 'array';
+                break;
+            case 'object':
+                schema.type = 'object';
+                break;
+            default:
+                // Keep original type for unknown types
+                schema.type = originalType;
+        }
+    }
+    // Recursively process nested schemas
+    if (schema.properties) {
+        Object.values(schema.properties).forEach((prop) => {
+            transformSchemaForUniversalCompatibility(prop);
+        });
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schema.items.forEach((item) => transformSchemaForUniversalCompatibility(item));
+        }
+        else {
+            transformSchemaForUniversalCompatibility(schema.items);
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        transformSchemaForUniversalCompatibility(schema.additionalProperties);
+    }
+    // Handle oneOf, anyOf, allOf
+    ['oneOf', 'anyOf', 'allOf'].forEach(key => {
+        if (schema[key] && Array.isArray(schema[key])) {
+            schema[key].forEach((subSchema) => transformSchemaForUniversalCompatibility(subSchema));
+        }
+    });
+}
+/**
+ * Transform JSON Schema types for Gemini compatibility
+ * Gemini requires uppercase type names and specific parameter structures
+ */
+function transformSchemaForGemini(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return schema;
+    }
+    const transformed = { ...schema };
+    // Transform type names to uppercase for Gemini
+    if (transformed.type) {
+        switch (transformed.type) {
+            case 'string':
+                transformed.type = 'STRING';
+                break;
+            case 'number':
+                transformed.type = 'NUMBER';
+                break;
+            case 'integer':
+                transformed.type = 'INTEGER';
+                break;
+            case 'boolean':
+                transformed.type = 'BOOLEAN';
+                break;
+            case 'array':
+                transformed.type = 'ARRAY';
+                break;
+            case 'object':
+                transformed.type = 'OBJECT';
+                break;
+        }
+    }
+    // Recursively transform nested properties
+    if (transformed.properties) {
+        const newProperties = {};
+        for (const [key, value] of Object.entries(transformed.properties)) {
+            newProperties[key] = transformSchemaForGemini(value);
+        }
+        transformed.properties = newProperties;
+    }
+    // Transform array items
+    if (transformed.items) {
+        transformed.items = transformSchemaForGemini(transformed.items);
+    }
+    // Transform oneOf/anyOf schemas
+    if (transformed.oneOf) {
+        transformed.oneOf = transformed.oneOf.map((item) => transformSchemaForGemini(item));
+    }
+    if (transformed.anyOf) {
+        transformed.anyOf = transformed.anyOf.map((item) => transformSchemaForGemini(item));
+    }
+    return transformed;
+}
+/**
+ * Transform tool schema for OpenAI compatibility
+ * OpenAI uses a wrapped function structure
+ */
+function transformSchemaForOpenAI(schema) {
+    // OpenAI expects a different structure - this is a placeholder
+    // for future OpenAI compatibility if needed
+    return schema;
+}
+/**
+ * Transform a tool definition based on client type
+ */
+export function transformToolForClient(tool, clientType) {
+    // Create a deep copy to avoid modifying the original
+    const transformedTool = JSON.parse(JSON.stringify(tool));
+    switch (clientType) {
+        case ClientType.GEMINI:
+            if (transformedTool.inputSchema) {
+                transformedTool.inputSchema = transformSchemaForGemini(transformedTool.inputSchema);
+            }
+            break;
+        case ClientType.OPENAI:
+            if (transformedTool.inputSchema) {
+                transformedTool.inputSchema = transformSchemaForOpenAI(transformedTool.inputSchema);
+            }
+            break;
+        case ClientType.CLAUDE:
+        case ClientType.UNKNOWN:
+        default:
+            // Claude and unknown clients use standard JSON Schema format
+            // No transformation needed
+            break;
+    }
+    return transformedTool;
+}
+/**
+ * Transform an array of tools based on client type
+ */
+export function transformToolsForClient(tools, clientType) {
+    return tools.map(tool => transformToolForClient(tool, clientType));
+}
+/**
+ * Enhanced error handling for client compatibility issues
+ */
+export function createCompatibilityError(clientType, originalError) {
+    const clientName = clientType.charAt(0).toUpperCase() + clientType.slice(1);
+    return new Error(`MCP Client Compatibility Issue (${clientName}): ${originalError.message}. ` +
+        `This may be due to differences in how ${clientName}-based clients handle MCP protocol. ` +
+        `Please ensure your client supports the MCP protocol version 2024-11-05 or later.`);
+}
+/**
+ * Log client compatibility information for debugging
+ */
+export function logClientCompatibilityInfo(clientType, toolCount, clientInfo) {
+    console.log(`[MCP Compatibility] Detected LLM model type: ${clientType}`);
+    console.log(`[MCP Compatibility] Serving ${toolCount} tools with ${clientType}-compatible schemas`);
+    if (clientInfo) {
+        console.log(`[MCP Compatibility] Client details:`, {
+            name: clientInfo.name,
+            version: clientInfo.version,
+            title: clientInfo.title
+        });
+    }
+    if (clientType === ClientType.GEMINI) {
+        console.log(`[MCP Compatibility] Applied Gemini-specific transformations: uppercase types, parameter structure adjustments`);
+    }
+    else if (clientType === ClientType.CLAUDE) {
+        console.log(`[MCP Compatibility] Using Claude-compatible standard JSON Schema format`);
+    }
+    else if (clientType === ClientType.OPENAI) {
+        console.log(`[MCP Compatibility] Using OpenAI-compatible schema format`);
+    }
+    else if (clientType === ClientType.UNKNOWN) {
+        console.log(`[MCP Compatibility] Using standard JSON Schema format for unknown LLM model`);
+    }
+}

package/build/utils/universal-schema-compatibility.js

@@ -0,0 +1,171 @@
+/**
+ * SPDX-FileCopyrightText: © 2025 Talib Kareem <taazkareem@icloud.com>
+ * SPDX-License-Identifier: MIT
+ *
+ * Universal Schema Compatibility for MCP Multi-LLM Support
+ *
+ * This module provides universal schema compatibility that works simultaneously
+ * with Claude, OpenAI, and Gemini clients without requiring client detection.
+ * The approach creates inherently compatible schemas rather than transforming them.
+ */
+/**
+ * Create a universal schema that works across all major LLM clients
+ * This approach uses flexible schema definitions that are inherently compatible
+ * with Claude, OpenAI, and Gemini without requiring client detection
+ */
+export function createUniversalSchema(originalSchema) {
+    if (!originalSchema || typeof originalSchema !== 'object') {
+        return originalSchema;
+    }
+    // Deep clone to avoid mutating original
+    const universalSchema = JSON.parse(JSON.stringify(originalSchema));
+    // Apply universal compatibility transformations
+    transformSchemaForUniversalCompatibility(universalSchema);
+    return universalSchema;
+}
+/**
+ * Transform a schema to be universally compatible with all LLM clients
+ * Uses flexible type definitions and multiple format support
+ */
+function transformSchemaForUniversalCompatibility(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return;
+    }
+    // Handle type field - make it flexible for all clients
+    if (schema.type) {
+        // Store original type for reference
+        const originalType = schema.type;
+        // For universal compatibility, we use an approach that works with all clients:
+        // 1. Keep the standard lowercase type (works with Claude/OpenAI)
+        // 2. Add format hints that Gemini can understand
+        // 3. Use flexible validation that doesn't break any client
+        switch (originalType.toLowerCase()) {
+            case 'string':
+                schema.type = 'string';
+                // Add format hints for better compatibility
+                if (!schema.format) {
+                    schema.format = 'text';
+                }
+                break;
+            case 'number':
+                schema.type = 'number';
+                break;
+            case 'integer':
+                schema.type = 'integer';
+                break;
+            case 'boolean':
+                schema.type = 'boolean';
+                break;
+            case 'array':
+                schema.type = 'array';
+                break;
+            case 'object':
+                schema.type = 'object';
+                break;
+            default:
+                // Keep original type for unknown types
+                schema.type = originalType;
+        }
+    }
+    // Recursively process nested schemas
+    if (schema.properties) {
+        Object.values(schema.properties).forEach((prop) => {
+            transformSchemaForUniversalCompatibility(prop);
+        });
+    }
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            schema.items.forEach((item) => transformSchemaForUniversalCompatibility(item));
+        }
+        else {
+            transformSchemaForUniversalCompatibility(schema.items);
+        }
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+        transformSchemaForUniversalCompatibility(schema.additionalProperties);
+    }
+    // Handle oneOf, anyOf, allOf
+    ['oneOf', 'anyOf', 'allOf'].forEach(key => {
+        if (schema[key] && Array.isArray(schema[key])) {
+            schema[key].forEach((subSchema) => transformSchemaForUniversalCompatibility(subSchema));
+        }
+    });
+}
+/**
+ * Transform tools to use universal schema compatibility
+ * This replaces the old client-specific transformation approach
+ */
+export function createUniversalTools(tools) {
+    return tools.map(tool => createUniversalTool(tool));
+}
+/**
+ * Transform a single tool to use universal schema compatibility
+ */
+export function createUniversalTool(tool) {
+    // Deep clone to avoid mutating original
+    const universalTool = JSON.parse(JSON.stringify(tool));
+    // Apply universal schema transformation to input schema
+    if (universalTool.inputSchema) {
+        universalTool.inputSchema = createUniversalSchema(universalTool.inputSchema);
+    }
+    // Apply universal schema transformation to output schema if present
+    if (universalTool.outputSchema) {
+        universalTool.outputSchema = createUniversalSchema(universalTool.outputSchema);
+    }
+    return universalTool;
+}
+/**
+ * Enhanced schema validation that works across all LLM clients
+ * This ensures schemas are robust and compatible
+ */
+export function validateUniversalSchema(schema) {
+    if (!schema || typeof schema !== 'object') {
+        return false;
+    }
+    // Check for required fields
+    if (schema.type && typeof schema.type !== 'string') {
+        return false;
+    }
+    // Validate properties structure
+    if (schema.properties) {
+        if (typeof schema.properties !== 'object') {
+            return false;
+        }
+        // Recursively validate nested properties
+        for (const prop of Object.values(schema.properties)) {
+            if (!validateUniversalSchema(prop)) {
+                return false;
+            }
+        }
+    }
+    // Validate array items
+    if (schema.items) {
+        if (Array.isArray(schema.items)) {
+            for (const item of schema.items) {
+                if (!validateUniversalSchema(item)) {
+                    return false;
+                }
+            }
+        }
+        else if (!validateUniversalSchema(schema.items)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Log universal compatibility information for debugging
+ */
+export function logUniversalCompatibilityInfo(toolCount) {
+    console.log(`[MCP Universal Compatibility] Serving ${toolCount} tools with universal schema format`);
+    console.log(`[MCP Universal Compatibility] Compatible with Claude, OpenAI, and Gemini clients simultaneously`);
+    console.log(`[MCP Universal Compatibility] No client detection required - works with all MCP clients`);
+}
+/**
+ * Create enhanced error messages for universal compatibility
+ */
+export function createUniversalCompatibilityError(originalError) {
+    return new Error(`MCP Universal Compatibility Issue: ${originalError.message}. ` +
+        `This server uses universal schema format compatible with Claude, OpenAI, and Gemini clients. ` +
+        `Please ensure your client supports MCP protocol version 2024-11-05 or later.`);
+}

package/build/virtual-sdk/generator.js

@@ -0,0 +1,53 @@
+function mapJsonTypeToTs(prop, indentLevel = 0) {
+    if (!prop)
+        return "any";
+    const indent = "  ".repeat(indentLevel);
+    if (prop.type === "array") {
+        return `${mapJsonTypeToTs(prop.items, indentLevel)}[]`;
+    }
+    if (prop.type === "object" && prop.properties) {
+        const lines = ["{"];
+        for (const [key, value] of Object.entries(prop.properties)) {
+            const isRequired = prop.required?.includes(key);
+            const childType = mapJsonTypeToTs(value, indentLevel + 1);
+            const doc = value.description ? `\n${indent}  /** ${value.description} */\n` : "";
+            lines.push(`${doc}${indent}  ${key}${isRequired ? "" : "?"}: ${childType};`);
+        }
+        lines.push(`${indent}}`);
+        return lines.join("\n");
+    }
+    if (prop.enum) {
+        return prop.enum.map((e) => typeof e === 'string' ? `"${e}"` : e).join(" | ");
+    }
+    if (prop.oneOf) {
+        return prop.oneOf.map((sub) => mapJsonTypeToTs(sub, indentLevel)).join(" | ");
+    }
+    switch (prop.type) {
+        case "string": return "string";
+        case "number": return "number";
+        case "integer": return "number";
+        case "boolean": return "boolean";
+        default: return "any";
+    }
+}
+export function generateVirtualFile(tools, moduleName) {
+    const header = `// ClickUp SDK - ${moduleName} module
+// This is a virtual file generated by the ClickUp MCP Server.
+// Use these functions to interact with the ClickUp API.
+import { callMCPTool } from "mcp-client"; // Abstracted client
+`;
+    const definitions = tools.map(tool => {
+        const funcName = tool.name;
+        const interfaceName = funcName.charAt(0).toUpperCase() + funcName.slice(1) + "Args";
+        const schema = tool.inputSchema;
+        const typeDef = `export interface ${interfaceName} ${mapJsonTypeToTs(schema, 0)}`;
+        const docBlock = `/**
+ * ${tool.description?.replace(/\n/g, "\n * ") || ""}
+ */`;
+        const funcDef = `export async function ${funcName}(args: ${interfaceName}): Promise<any> {
+  return await callMCPTool('${funcName}', args);
+}`;
+        return `${typeDef}\n\n${docBlock}\n${funcDef}`;
+    });
+    return [header, ...definitions].join("\n\n");
+}

package/build/virtual-sdk/registry.js

@@ -0,0 +1,45 @@
+import { generateVirtualFile } from "./generator.js";
+// Import all definitions
+import { createTaskTool, updateTaskTool, moveTaskTool, duplicateTaskTool, getTaskTool, deleteTaskTool, getTasksTool, getTaskCommentsTool, createTaskCommentTool } from "../tools/task/single-operations.js";
+import { attachTaskFileTool } from "../tools/task/attachments.js";
+import { createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool } from "../tools/task/bulk-operations.js";
+import { getTaskTimeEntriesTool, startTimeTrackingTool, stopTimeTrackingTool, addTimeEntryTool, deleteTimeEntryTool, getCurrentTimeEntryTool } from "../tools/task/time-tracking.js";
+import { getWorkspaceTasksTool } from "../tools/task/workspace-operations.js";
+import { createListTool, createListInFolderTool, getListTool, updateListTool, deleteListTool } from "../tools/list.js";
+import { createFolderTool, getFolderTool, updateFolderTool, deleteFolderTool } from "../tools/folder.js";
+import { getSpaceTagsTool, createSpaceTagTool, updateSpaceTagTool, deleteSpaceTagTool, addTagToTaskTool, removeTagFromTaskTool } from "../tools/tag.js";
+import { workspaceHierarchyTool } from "../tools/workspace.js";
+import { getWorkspaceMembersTool, findMemberByNameTool, resolveAssigneesTool } from "../tools/member.js";
+import { createDocumentTool, getDocumentTool, listDocumentsTool, listDocumentPagesTool, getDocumentPagesTool, createDocumentPageTool, updateDocumentPageTool } from "../tools/documents.js";
+const MODULES = {
+    "tasks": [createTaskTool, getTaskTool, updateTaskTool, deleteTaskTool, moveTaskTool, duplicateTaskTool, getTasksTool, attachTaskFileTool],
+    "bulk": [createBulkTasksTool, updateBulkTasksTool, moveBulkTasksTool, deleteBulkTasksTool],
+    "search": [getWorkspaceTasksTool],
+    "comments": [getTaskCommentsTool, createTaskCommentTool],
+    "time": [getTaskTimeEntriesTool, startTimeTrackingTool, stopTimeTrackingTool, addTimeEntryTool, deleteTimeEntryTool, getCurrentTimeEntryTool],
+    "lists": [createListTool, createListInFolderTool, getListTool, updateListTool, deleteListTool],
+    "folders": [createFolderTool, getFolderTool, updateFolderTool, deleteFolderTool],
+    "tags": [getSpaceTagsTool, createSpaceTagTool, updateSpaceTagTool, deleteSpaceTagTool, addTagToTaskTool, removeTagFromTaskTool],
+    "members": [getWorkspaceMembersTool, findMemberByNameTool, resolveAssigneesTool],
+    "docs": [createDocumentTool, getDocumentTool, listDocumentsTool, listDocumentPagesTool, getDocumentPagesTool, createDocumentPageTool, updateDocumentPageTool],
+    "workspace": [workspaceHierarchyTool]
+};
+export class VirtualSDKRegistry {
+    getResourcesList() {
+        return Object.keys(MODULES).map(module => ({
+            uri: `source://clickup/${module}.ts`,
+            name: `ClickUp ${module} SDK`,
+            description: `TypeScript definitions for ${module} operations`,
+            mimeType: "application/typescript"
+        }));
+    }
+    getResourceContent(uri) {
+        const url = new URL(uri);
+        const path = url.pathname.replace(/^\//, '');
+        const moduleKey = path.replace('clickup/', '').replace('.ts', '');
+        if (MODULES[moduleKey]) {
+            return generateVirtualFile(MODULES[moduleKey], moduleKey);
+        }
+        throw new Error(`Virtual file not found: ${uri}`);
+    }
+}