arbentia-dataverse-mcp 1.0.2

package/README.md

@@ -0,0 +1,73 @@
+# Dataverse MCP Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for Microsoft Dataverse.
+
+This server provides tools to explore Dataverse table definitions (metadata), columns (fields), relationships, keys, and OptionSets (Choice columns) using natural language through an MCP Client (like Claude Desktop or other AI agents).
+
+## Features
+
+- **Refresh Metadata**: Downloads the full `$metadata` definition and `StringMaps` (Local OptionSets) from your Dataverse environment.
+- **List Tables**: Search for tables by name pattern.
+- **Get Table Details**: Get detailed schema information for specific tables, including Fields, Relationships, and Keys.
+- **Get Global OptionSets**: Retrieve details for global choices (Global OptionSets).
+- **Get Local OptionSets**: Retrieve values for local choices (StringMaps) specific to an entity and attribute.
+
+## Installation
+
+```bash
+npm install -g dataverse-mcp
+```
+
+## Usage
+
+### Prerequisites
+
+- A Microsoft Dataverse environment.
+- A user account with permissions to read metadata.
+- An MCP Client.
+
+### Running the Server
+
+You can run the server directly using `npx` or by installing it globally.
+
+**Using npx:**
+
+```bash
+npx dataverse-mcp --url "https://your-org.crm.dynamics.com"
+```
+
+**Configuration in Claude Desktop:**
+
+Add the following to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "dataverse": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "dataverse-mcp",
+        "--url",
+        "https://your-org.crm.dynamics.com"
+      ]
+    }
+  }
+}
+```
+
+### Authentication
+
+This tool uses `@azure/identity`'s `InteractiveBrowserCredential`. When you first use a tool that requires access, a browser window will open asking you to log in to your Microsoft account.
+
+## Tools
+
+- `refresh_metadata`: Redownloads the metadata cache.
+- `list_tables_by_name`: Lists tables matching a regex pattern.
+- `get_tables_details`: Detailed schema for given tables. Supports filtering by `Fields`, `Relationships`, or `Keys`.
+- `get_global_optionset_details`: Details for Global OptionSets.
+- `get_local_optionset_details`: Details for Local OptionSets (StringMaps) for specific entities.
+
+## License
+
+MIT

package/auth.js

@@ -0,0 +1,38 @@
+import { InteractiveBrowserCredential } from "@azure/identity";
+
+// Constants
+const AZURE_CLI_CLIENT_ID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46";
+const COMMON_TENANT_ID = "common";
+
+/**
+ * Gets an access token for the specified Dataverse URL.
+ * @param {string} dataverseUrl The URL of the Dataverse environment (e.g., https://org.crm.dynamics.com).
+ * @returns {Promise<string>} The access token.
+ */
+export async function getAccessToken(dataverseUrl) {
+    console.error(`[Auth] Authenticating against ${dataverseUrl}...`); // Stderr for logs so stdout is clean for MCP
+    
+    // Ensure URL is clean for scope
+    const url = new URL(dataverseUrl);
+    const scope = `${url.origin}/user_impersonation`; // Or .default
+
+    try {
+        const credential = new InteractiveBrowserCredential({
+            clientId: AZURE_CLI_CLIENT_ID,
+            tenantId: COMMON_TENANT_ID,
+            redirectUri: "http://localhost:8400", // Azure CLI often uses this or similar
+        });
+
+        const tokenResponse = await credential.getToken([scope]);
+        
+        if (!tokenResponse) {
+            throw new Error("Failed to acquire token.");
+        }
+
+        console.error(`[Auth] Successfully authenticated.`);
+        return tokenResponse.token;
+    } catch (error) {
+        console.error(`[Auth] Error: ${error.message}`);
+        throw error;
+    }
+}

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../index.js';

package/index.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+    CallToolRequestSchema,
+    ListResourcesRequestSchema,
+    ListToolsRequestSchema,
+    ReadResourceRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import yargs from 'yargs/yargs';
+import { hideBin } from 'yargs/helpers';
+import fs from 'fs-extra';
+import path from 'path';
+import { getAccessToken } from './auth.js';
+import { ensureMetadata } from './metadata.js';
+
+// Tool Imports
+import * as refreshMetadata from './tools/refreshMetadata.js';
+import * as listTablesByName from './tools/listTablesByName.js';
+import * as getTablesDetails from './tools/getTablesDetails.js';
+import * as getGlobalOptionSetDetails from './tools/getGlobalOptionSetDetails.js';
+import * as getLocalOptionSetDetails from './tools/getLocalOptionSetDetails.js';
+
+// Parse arguments
+const argv = yargs(hideBin(process.argv))
+    .option('url', {
+        alias: 'u',
+        type: 'string',
+        description: 'Dataverse Environment URL',
+        demandOption: true
+    })
+    .help()
+    .argv;
+
+const dataverseUrl = argv.url;
+
+// Initialize Server
+const server = new Server(
+    {
+        name: "dataverse-mcp",
+        version: "1.0.0",
+    },
+    {
+        capabilities: {
+            resources: {},
+            tools: {},
+        },
+    }
+);
+
+// Resource for metadata
+const METADATA_RESOURCE_URI = "dataverse://metadata";
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: METADATA_RESOURCE_URI,
+                name: "Dataverse Metadata",
+                mimeType: "text/xml",
+                description: "The full OData $metadata XML definition for the Dataverse environment",
+            },
+        ],
+    };
+});
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    if (request.params.uri === METADATA_RESOURCE_URI) {
+        const filePath = path.resolve(process.cwd(), '.dataversemetadata', 'metadata.xml');
+
+        if (!await fs.pathExists(filePath)) {
+            throw new Error("Metadata file not found. It might be downloading or failed.");
+        }
+
+        const content = await fs.readFile(filePath, 'utf-8');
+        return {
+            contents: [
+                {
+                    uri: METADATA_RESOURCE_URI,
+                    mimeType: "text/xml",
+                    text: content,
+                },
+            ],
+        };
+    }
+    throw new Error("Resource not found");
+});
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            refreshMetadata.toolDefinition,
+            listTablesByName.toolDefinition,
+            getTablesDetails.toolDefinition,
+            getGlobalOptionSetDetails.toolDefinition,
+            getLocalOptionSetDetails.toolDefinition,
+        ],
+    };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        if (name === refreshMetadata.toolDefinition.name) {
+            return await refreshMetadata.handleRefreshMetadata(args, dataverseUrl);
+        }
+        if (name === listTablesByName.toolDefinition.name) {
+            return await listTablesByName.handleListTablesByName(args);
+        }
+        if (name === getTablesDetails.toolDefinition.name) {
+            return await getTablesDetails.handleGetTablesDetails(args);
+        }
+        if (name === getGlobalOptionSetDetails.toolDefinition.name) {
+            return await getGlobalOptionSetDetails.handleGetGlobalOptionSetDetails(args);
+        }
+        if (name === getLocalOptionSetDetails.toolDefinition.name) {
+            return await getLocalOptionSetDetails.handleGetLocalOptionSetDetails(args);
+        }
+    } catch (err) {
+        return {
+            content: [{ type: "text", text: `Error executing tool ${name}: ${err.message}` }],
+            isError: true,
+        };
+    }
+
+    throw new Error("Tool not found");
+});
+
+// Startup logic
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("MCP Server running on stdio");
+
+    // Trigger initial download (or ensure existence) in background
+    console.error("Server started. Metadata will be loaded on demand.");
+}
+
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/metadata.js

@@ -0,0 +1,277 @@
+import axios from 'axios';
+import fs from 'fs-extra';
+import path from 'path';
+import { XMLParser } from 'fast-xml-parser';
+
+let cachedParsedData = null;
+
+// Helper to get parser
+function getParser() {
+    return new XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_"
+    });
+}
+
+/**
+ * Ensures metadata exists. If not, downloads it.
+ * @param {string} dataverseUrl 
+ * @param {string} token 
+ */
+export async function ensureMetadata(dataverseUrl, token) {
+    const cacheDir = path.resolve(process.cwd(), '.dataversemetadata');
+    const filePath = path.join(cacheDir, 'metadata.xml');
+
+    if (await fs.pathExists(filePath)) {
+        console.error(`[Metadata] Metadata already exists at ${filePath}. Skipping download.`);
+        return filePath;
+    }
+
+    return await downloadMetadata(dataverseUrl, token);
+}
+
+/**
+ * Downloads the Dataverse $metadata file and saves it locally.
+ * @param {string} dataverseUrl The Dataverse environment URL.
+ * @param {string} token The access token.
+ */
+export async function downloadMetadata(dataverseUrl, token) {
+    const url = new URL(dataverseUrl);
+    const baseUrl = url.origin;
+    const metadataUrl = `${baseUrl}/api/data/v9.2/$metadata`;
+    const cacheDir = path.resolve(process.cwd(), '.dataversemetadata');
+    const filePath = path.join(cacheDir, 'metadata.xml');
+
+    console.error(`[Metadata] Downloading from ${metadataUrl}...`);
+
+    try {
+        const response = await axios.get(metadataUrl, {
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Accept': 'application/xml',
+            },
+            responseType: 'text'
+        });
+
+        await fs.ensureDir(cacheDir);
+        await fs.writeFile(filePath, response.data);
+        console.error(`[Metadata] Saved to ${filePath}`);
+
+        await downloadStringMaps(baseUrl, token);
+
+        // Invalidate cache on new download
+        cachedParsedData = null;
+
+        return filePath;
+    } catch (error) {
+        console.error(`[Metadata] Download failed: ${error.message}`);
+        if (error.response) {
+            console.error(`[Metadata] Server responded with: ${error.response.status} ${error.response.statusText}`);
+        }
+        throw error;
+    }
+}
+
+async function downloadStringMaps(baseUrl, token) {
+    const records = [];
+    let nextLink = `${baseUrl}/api/data/v9.2/stringmaps?$select=objecttypecode,attributename,attributevalue,value,displayorder`;
+
+    console.error(`[Metadata] Downloading StringMaps...`);
+
+    while (nextLink) {
+        try {
+            const response = await axios.get(nextLink, {
+                headers: {
+                    'Authorization': `Bearer ${token}`,
+                    'Accept': 'application/json',
+                    'Prefer': 'odata.include-annotations="*"'
+                }
+            });
+
+            if (response.data.value) {
+                records.push(...response.data.value);
+            }
+
+            nextLink = response.data['@odata.nextLink'];
+            if (nextLink) console.error(`[Metadata] Fetching next page of StringMaps...`);
+
+        } catch (error) {
+            console.error(`[Metadata] Failed to download StringMaps page: ${error.message}`);
+            // Decide if we should fail the whole process or just log warning. 
+            // For now, let's log and break to save what we have.
+            break;
+        }
+    }
+
+    const cacheDir = path.resolve(process.cwd(), '.dataversemetadata');
+    const filePath = path.join(cacheDir, 'stringmaps.json');
+    await fs.writeJson(filePath, records);
+    console.error(`[Metadata] Saved ${records.length} StringMaps to ${filePath}`);
+}
+
+async function getParsedMetadata() {
+    if (cachedParsedData) return cachedParsedData;
+
+    const cacheDir = path.resolve(process.cwd(), '.dataversemetadata');
+    const filePath = path.join(cacheDir, 'metadata.xml');
+
+    if (!await fs.pathExists(filePath)) {
+        throw new Error("Metadata file not found. Please run the 'refresh_metadata' tool to download it.");
+    }
+
+    console.error(`[Metadata] Parsing metadata from ${filePath}...`);
+    const xmlData = await fs.readFile(filePath, 'utf-8');
+    const parser = getParser();
+    cachedParsedData = parser.parse(xmlData);
+    return cachedParsedData;
+}
+
+/**
+ * Returns a list of EntityType names.
+ * @returns {Promise<string[]>} List of entity names.
+ */
+export async function getEntities() {
+    const parsed = await getParsedMetadata();
+    const entities = [];
+
+    const schemas = parsed['edmx:Edmx']['edmx:DataServices']['Schema'];
+    const schemaList = Array.isArray(schemas) ? schemas : [schemas];
+
+    for (const schema of schemaList) {
+        if (schema.EntityType) {
+            const entityTypes = Array.isArray(schema.EntityType) ? schema.EntityType : [schema.EntityType];
+            for (const et of entityTypes) {
+                if (et['@_Name']) {
+                    entities.push(et['@_Name']);
+                }
+            }
+        }
+    }
+    return entities;
+}
+
+/**
+ * Returns details for valid entities.
+ * @param {string[]} tableNames 
+ * @param {'Fields'|'Relationships'|'Keys'|'All'} detailType
+ */
+export async function getEntityDetails(tableNames, detailType = 'All') {
+    const parsed = await getParsedMetadata();
+    const result = {};
+    const lowerNames = tableNames.map(n => n.toLowerCase());
+
+    const schemas = parsed['edmx:Edmx']['edmx:DataServices']['Schema'];
+    const schemaList = Array.isArray(schemas) ? schemas : [schemas];
+
+    for (const schema of schemaList) {
+        if (schema.EntityType) {
+            const entityTypes = Array.isArray(schema.EntityType) ? schema.EntityType : [schema.EntityType];
+            for (const et of entityTypes) {
+                if (et['@_Name'] && lowerNames.includes(et['@_Name'].toLowerCase())) {
+                    const cleanEt = { ...et };
+                    delete cleanEt['Action'];
+                    delete cleanEt['Function'];
+
+                    if (detailType !== 'All') {
+                        const keepProps = [];
+                        if (detailType === 'Fields') keepProps.push('Property');
+                        if (detailType === 'Relationships') keepProps.push('NavigationProperty');
+                        if (detailType === 'Keys') keepProps.push('Key');
+
+                        if (!keepProps.includes('Property')) delete cleanEt['Property'];
+                        if (!keepProps.includes('NavigationProperty')) delete cleanEt['NavigationProperty'];
+                        if (!keepProps.includes('Key')) delete cleanEt['Key'];
+                    }
+                    result[et['@_Name']] = cleanEt;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Returns details for valid Global OptionSets (EnumTypes).
+ * @param {string[]} optionSetNames 
+ */
+export async function getGlobalOptionSetDetails(optionSetNames) {
+    const parsed = await getParsedMetadata();
+    const result = {};
+    const lowerNames = optionSetNames.map(n => n.toLowerCase());
+
+    const schemas = parsed['edmx:Edmx']['edmx:DataServices']['Schema'];
+    const schemaList = Array.isArray(schemas) ? schemas : [schemas];
+
+    for (const schema of schemaList) {
+        if (schema.EnumType) {
+            const enumTypes = Array.isArray(schema.EnumType) ? schema.EnumType : [schema.EnumType];
+            for (const et of enumTypes) {
+                if (!et['@_Name']) continue;
+
+                const name = et['@_Name'].toLowerCase();
+                const namespace = schema['@_Namespace'] ? schema['@_Namespace'].toLowerCase() : "";
+                const fullName = namespace ? `${namespace}.${name}` : name;
+
+                const matchedRequest = lowerNames.find(req => req === name || req === fullName);
+
+                if (matchedRequest) {
+                    const key = schema['@_Namespace'] ? `${schema['@_Namespace']}.${et['@_Name']}` : et['@_Name'];
+                    result[key] = et;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+/**
+ * Returns details for Local OptionSets from stringmaps.
+ * @param {Object.<string, string[]>} requestMap Map of entity logical name to array of attribute names.
+ */
+export async function getLocalOptionSetDetails(requestMap) {
+    const cacheDir = path.resolve(process.cwd(), '.dataversemetadata');
+    const stringMapsPath = path.join(cacheDir, 'stringmaps.json');
+    const result = {};
+
+    if (!await fs.pathExists(stringMapsPath)) {
+        console.warn("[Metadata] stringmaps.json not found.");
+        return result;
+    }
+
+    try {
+        const stringMaps = await fs.readJson(stringMapsPath);
+
+        // requestMap structure: { "account": ["statuscode", "industrycode"], "contact": ["..."] }
+        // Normalize request keys to lowercase
+        const normalizedRequest = {};
+        for (const [ent, attrs] of Object.entries(requestMap)) {
+            normalizedRequest[ent.toLowerCase()] = attrs.map(a => a.toLowerCase());
+        }
+
+        // Iterate stringmaps
+        for (const sm of stringMaps) {
+            // "objecttypecode" is expected to be the entity logical name (string) based on user input.
+            // If it's not, we might fail here, but we rely on user's instruction.
+            const entityName = (sm['objecttypecode'] || '').toLowerCase();
+            const attrName = (sm['attributename'] || '').toLowerCase();
+
+            if (normalizedRequest[entityName] && normalizedRequest[entityName].includes(attrName)) {
+                if (!result[entityName]) result[entityName] = {};
+                if (!result[entityName][attrName]) result[entityName][attrName] = [];
+
+                result[entityName][attrName].push({
+                    Display: sm['value'],
+                    OptionSetValue: sm['attributevalue']
+                });
+            }
+        }
+
+        // Sort options by something? Maybe displayorder if available, but user didn't ask.
+        // Let's ensure integer parsing for OptionSetValue if it's a string? 
+        // stringmaps json usually has numbers for attributevalue.
+    } catch (e) {
+        console.error(`[Metadata] Error reading/processing stringmaps: ${e}`);
+    }
+
+    return result;
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "arbentia-dataverse-mcp",
+  "version": "1.0.2",
+  "description": "Model Context Protocol (MCP) server for Microsoft Dataverse Metadata",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "arbentia-dataverse-mcp": "./bin/cli.js"
+  },
+  "files": [
+    "bin/cli.js",
+    "index.js",
+    "auth.js",
+    "metadata.js",
+    "tools/*.js"
+  ],
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "dataverse",
+    "dynamics-365",
+    "metadata",
+    "model-context-protocol"
+  ],
+  "author": "Arbentia",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/arbentia/dataverse-mcp.git"
+  },
+  "dependencies": {
+    "@azure/identity": "^4.0.0",
+    "@modelcontextprotocol/sdk": "^1.25.0",
+    "axios": "^1.6.0",
+    "fast-xml-parser": "^5.3.3",
+    "fs-extra": "^11.2.0",
+    "yargs": "^17.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/tools/getGlobalOptionSetDetails.js

@@ -0,0 +1,29 @@
+import { getGlobalOptionSetDetails } from '../metadata.js';
+
+export const toolDefinition = {
+    name: "get_global_optionset_details",
+    description: "Get schema details for a list of Dataverse Global OptionSets (EnumTypes)",
+    inputSchema: {
+        type: "object",
+        properties: {
+            optionset_names: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of OptionSet names (e.g. ['prv_budgettypes', 'account_statuscode'])",
+            },
+        },
+        required: ["optionset_names"],
+    },
+};
+
+export async function handleGetGlobalOptionSetDetails(args) {
+    const { optionset_names } = args;
+    const details = await getGlobalOptionSetDetails(optionset_names);
+
+    return {
+        content: [{
+            type: "text",
+            text: JSON.stringify(details, null, 2)
+        }],
+    };
+}

package/tools/getLocalOptionSetDetails.js

@@ -0,0 +1,32 @@
+import { getLocalOptionSetDetails } from '../metadata.js';
+
+export const toolDefinition = {
+    name: "get_local_optionset_details",
+    description: "Get details for local OptionSets (StringMaps) for specified entities and attributes.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            request_map: {
+                type: "object",
+                additionalProperties: {
+                    type: "array",
+                    items: { type: "string" }
+                },
+                description: "Map of entity logical names to lists of attribute names. Example: { 'account': ['statuscode', 'industrycode'] }",
+            },
+        },
+        required: ["request_map"],
+    },
+};
+
+export async function handleGetLocalOptionSetDetails(args) {
+    const { request_map } = args;
+    const details = await getLocalOptionSetDetails(request_map);
+
+    return {
+        content: [{
+            type: "text",
+            text: JSON.stringify(details, null, 2)
+        }],
+    };
+}

package/tools/getTablesDetails.js

@@ -0,0 +1,34 @@
+import { getEntityDetails } from '../metadata.js';
+
+export const toolDefinition = {
+    name: "get_tables_details",
+    description: "Get full schema details for a list of Dataverse tables (entities).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            table_names: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of logical table names (e.g. ['account', 'contact'])",
+            },
+            detail_type: {
+                type: "string",
+                enum: ["Fields", "Relationships", "Keys", "All"],
+                description: "Optional filter for details. Defaults to 'All'.",
+            },
+        },
+        required: ["table_names"],
+    },
+};
+
+export async function handleGetTablesDetails(args) {
+    const { table_names, detail_type } = args;
+    const details = await getEntityDetails(table_names, detail_type);
+
+    return {
+        content: [{
+            type: "text",
+            text: JSON.stringify(details, null, 2)
+        }],
+    };
+}

package/tools/listTablesByName.js

@@ -0,0 +1,48 @@
+import { getEntities } from '../metadata.js';
+
+export const toolDefinition = {
+    name: "list_tables_by_name",
+    description: "Search for Dataverse tables (entities) by name using a regex pattern. Returns a paginated list of matching entity names.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            name_pattern: {
+                type: "string",
+                description: "Regex pattern to match entity names (case insensitive)",
+            },
+            page: {
+                type: "number",
+                description: "Page number (1-based, default: 1)",
+            },
+            size: {
+                type: "number",
+                description: "Page size (default: 50)",
+            },
+        },
+        required: ["name_pattern"],
+    },
+};
+
+export async function handleListTablesByName(args) {
+    const { name_pattern, page = 1, size = 50 } = args;
+    const entities = await getEntities();
+
+    const regex = new RegExp(name_pattern, 'i');
+    const matches = entities.filter(e => regex.test(e));
+
+    // Pagination
+    const startIndex = (page - 1) * size;
+    const pagedResults = matches.slice(startIndex, startIndex + size);
+
+    return {
+        content: [{
+            type: "text",
+            text: JSON.stringify({
+                page,
+                total_matches: matches.length,
+                total_pages: Math.ceil(matches.length / size),
+                results: pagedResults
+            }, null, 2)
+        }],
+    };
+}

package/tools/refreshMetadata.js

@@ -0,0 +1,27 @@
+import { downloadMetadata } from '../metadata.js';
+import { getAccessToken } from '../auth.js';
+
+export const toolDefinition = {
+    name: "refresh_metadata",
+    description: "Force refresh/redownload of the Dataverse metadata",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+};
+
+export async function handleRefreshMetadata(args, dataverseUrl) {
+    // Note: dataverseUrl needs to be passed in from main server context
+    try {
+        const token = await getAccessToken(dataverseUrl);
+        await downloadMetadata(dataverseUrl, token);
+        return {
+            content: [{ type: "text", text: "Metadata refreshed successfully." }],
+        };
+    } catch (err) {
+        return {
+            content: [{ type: "text", text: `Failed to refresh metadata: ${err.message}` }],
+            isError: true,
+        };
+    }
+}