Corregir implementación MCP Metabase con API correcta

- Usar registerTool con 3 argumentos (nombre, metadata, handler)
- InputSchema y outputSchema como objetos planos con propiedades Zod
- Handlers retornan {content, structuredContent} o {content, isError}
- Transport sin endpoint, usar sessionIdGenerator: undefined
- Corregir tipo HeadersInit a Record<string, string>
- Soluciona errores de TypeScript en el build

mcp-metabase-server/src/index.ts

@@ -20,12 +20,15 @@ async function metabaseFetch<T = any>(
 ): Promise<T> {
   const url = `${METABASE_URL}${endpoint}`;
 
-  const headers: HeadersInit = {
+  const headers: Record<string, string> = {
     'Content-Type': 'application/json',
     'X-API-KEY': METABASE_API_KEY,
-    ...options.headers,
   };
 
+  if (options.headers) {
+    Object.assign(headers, options.headers);
+  }
+
   try {
     const response = await fetch(url, {
       ...options,
@@ -53,24 +56,23 @@ const server = new McpServer({
 // ==================== Herramientas ====================
 
 // 1. Listar/buscar cards
-server.registerTool({
-  name: 'metabase_cards',
-  metadata: {
+server.registerTool(
+  'metabase_cards',
+  {
     title: 'Listar o buscar Cards/Questions',
     description: 'Lista todas las cards o busca cards por nombre/colección',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       action: z.enum(['list', 'search']).describe('Acción a realizar'),
       query: z.string().optional().describe('Término de búsqueda (para action=search)'),
       collection_id: z.number().optional().describe('ID de colección para filtrar'),
-  }),
-  outputSchema: z.object({
+    },
+    outputSchema: {
       cards: z.array(z.any()),
       count: z.number(),
-  }),
-  handler: async (input) => {
-    const { action, query, collection_id } = input;
-
+    }
+  },
+  async ({ action, query, collection_id }) => {
+    try {
       let endpoint = '/api/card';
       const params = new URLSearchParams();
 
@@ -93,50 +95,71 @@ server.registerTool({
         );
       }
 
-    return {
+      const result = {
         cards: filteredCards,
         count: filteredCards.length,
       };
-  },
-});
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 2. Obtener detalles de una card
-server.registerTool({
-  name: 'metabase_card_info',
-  metadata: {
+server.registerTool(
+  'metabase_card_info',
+  {
     title: 'Obtener detalles de una Card',
     description: 'Obtiene información detallada de una card específica por su ID',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       card_id: z.number().describe('ID de la card'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
-    const { card_id } = input;
-    const card = await metabaseFetch(`/api/card/${card_id}`);
-    return card;
     },
-});
+    outputSchema: z.any()
+  },
+  async ({ card_id }) => {
+    try {
+      const card = await metabaseFetch(`/api/card/${card_id}`);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(card, null, 2) }],
+        structuredContent: card
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 3. Ejecutar card con parámetros
-server.registerTool({
-  name: 'metabase_execute_card',
-  metadata: {
+server.registerTool(
+  'metabase_execute_card',
+  {
     title: 'Ejecutar Card con parámetros',
     description: 'Ejecuta una card/question existente, opcionalmente con parámetros',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       card_id: z.number().describe('ID de la card a ejecutar'),
       parameters: z.array(z.object({
-      type: z.string().describe('Tipo de parámetro (ej: date/single, category, etc.)'),
+        type: z.string().describe('Tipo de parámetro'),
         target: z.any().describe('Target del parámetro'),
         value: z.any().describe('Valor del parámetro'),
       })).optional().describe('Parámetros para la query'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
-    const { card_id, parameters } = input;
-
+    },
+    outputSchema: z.any()
+  },
+  async ({ card_id, parameters }) => {
+    try {
       const body: any = {};
       if (parameters && parameters.length > 0) {
         body.parameters = parameters;
@@ -147,18 +170,27 @@ server.registerTool({
         body: JSON.stringify(body),
       });
 
-    return result;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 4. Crear nueva card
-server.registerTool({
-  name: 'metabase_create_card',
-  metadata: {
+server.registerTool(
+  'metabase_create_card',
+  {
     title: 'Crear nueva Card',
     description: 'Crea una nueva card/question en Metabase',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       name: z.string().describe('Nombre de la card'),
       description: z.string().optional().describe('Descripción de la card'),
       dataset_query: z.object({
@@ -166,29 +198,31 @@ server.registerTool({
         database: z.number().describe('ID de la base de datos'),
         native: z.object({
           query: z.string().describe('Query SQL'),
-        template_tags: z.record(z.any()).optional().describe('Tags de template para parámetros'),
-      }).optional().describe('Query nativa SQL (si type=native)'),
-      query: z.any().optional().describe('Query MBQL (si type=query)'),
+          template_tags: z.record(z.any()).optional().describe('Tags de template'),
+        }).optional(),
+        query: z.any().optional(),
       }).describe('Configuración de la query'),
-    display: z.string().default('table').describe('Tipo de visualización (table, bar, line, etc.)'),
+      display: z.string().default('table').describe('Tipo de visualización'),
       visualization_settings: z.record(z.any()).optional().describe('Configuración de visualización'),
-    collection_id: z.number().optional().describe('ID de la colección donde guardar la card'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
+      collection_id: z.number().optional().describe('ID de la colección'),
+    },
+    outputSchema: z.any()
+  },
+  async ({ name, description, dataset_query, display, visualization_settings, collection_id }) => {
+    try {
       const body: any = {
-      name: input.name,
-      dataset_query: input.dataset_query,
-      display: input.display,
-      visualization_settings: input.visualization_settings || {},
+        name,
+        dataset_query,
+        display: display || 'table',
+        visualization_settings: visualization_settings || {},
       };
 
-    if (input.description) {
-      body.description = input.description;
+      if (description) {
+        body.description = description;
       }
 
-    if (input.collection_id !== undefined) {
-      body.collection_id = input.collection_id;
+      if (collection_id !== undefined) {
+        body.collection_id = collection_id;
       }
 
       const result = await metabaseFetch('/api/card', {
@@ -196,28 +230,37 @@ server.registerTool({
         body: JSON.stringify(body),
       });
 
-    return result;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
-// 5. Actualizar card (nombre/descripción)
-server.registerTool({
-  name: 'metabase_update_card',
-  metadata: {
+// 5. Actualizar card
+server.registerTool(
+  'metabase_update_card',
+  {
     title: 'Actualizar Card',
     description: 'Actualiza el nombre y/o descripción de una card existente',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       card_id: z.number().describe('ID de la card a actualizar'),
-    name: z.string().optional().describe('Nuevo nombre de la card'),
-    description: z.string().optional().describe('Nueva descripción de la card'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
-    const { card_id, name, description } = input;
-
+      name: z.string().optional().describe('Nuevo nombre'),
+      description: z.string().optional().describe('Nueva descripción'),
+    },
+    outputSchema: z.any()
+  },
+  async ({ card_id, name, description }) => {
+    try {
       if (!name && !description) {
-      throw new Error('Debe proporcionar al menos name o description para actualizar');
+        throw new Error('Debe proporcionar al menos name o description');
       }
 
       const body: any = {};
@@ -229,42 +272,62 @@ server.registerTool({
         body: JSON.stringify(body),
       });
 
-    return result;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 6. Listar colecciones
-server.registerTool({
-  name: 'metabase_collections',
-  metadata: {
+server.registerTool(
+  'metabase_collections',
+  {
     title: 'Listar Colecciones',
     description: 'Lista todas las colecciones disponibles en Metabase',
+    inputSchema: {},
+    outputSchema: z.array(z.any())
   },
-  inputSchema: z.object({}),
-  outputSchema: z.array(z.any()),
-  handler: async () => {
+  async () => {
+    try {
       const collections = await metabaseFetch<any[]>('/api/collection');
-    return collections;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(collections, null, 2) }],
+        structuredContent: collections
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 7. Listar bases de datos
-server.registerTool({
-  name: 'metabase_databases',
-  metadata: {
+server.registerTool(
+  'metabase_databases',
+  {
     title: 'Listar Bases de Datos',
     description: 'Lista todas las bases de datos configuradas en Metabase',
+    inputSchema: {
+      include_tables: z.boolean().optional().default(false).describe('Incluir metadata de tablas'),
     },
-  inputSchema: z.object({
-    include_tables: z.boolean().optional().default(false).describe('Incluir metadatos de tablas y campos'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
-    const { include_tables } = input;
+    outputSchema: z.any()
+  },
+  async ({ include_tables }) => {
+    try {
       const databases = await metabaseFetch<any[]>('/api/database');
 
       if (include_tables) {
-      // Obtener metadata completa de cada base de datos
         const databasesWithMetadata = await Promise.all(
           databases.map(async (db) => {
             try {
@@ -276,45 +339,79 @@ server.registerTool({
             }
           })
         );
-      return databasesWithMetadata;
+        return {
+          content: [{ type: 'text', text: JSON.stringify(databasesWithMetadata, null, 2) }],
+          structuredContent: databasesWithMetadata
+        };
       }
 
-    return databases;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(databases, null, 2) }],
+        structuredContent: databases
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 8. Listar dashboards
-server.registerTool({
-  name: 'metabase_dashboards',
-  metadata: {
+server.registerTool(
+  'metabase_dashboards',
+  {
     title: 'Listar Dashboards',
     description: 'Lista todos los dashboards disponibles',
+    inputSchema: {},
+    outputSchema: z.array(z.any())
   },
-  inputSchema: z.object({}),
-  outputSchema: z.array(z.any()),
-  handler: async () => {
+  async () => {
+    try {
       const dashboards = await metabaseFetch<any[]>('/api/dashboard');
-    return dashboards;
-  },
-});
+      return {
+        content: [{ type: 'text', text: JSON.stringify(dashboards, null, 2) }],
+        structuredContent: dashboards
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // 9. Obtener detalles de un dashboard
-server.registerTool({
-  name: 'metabase_dashboard_info',
-  metadata: {
+server.registerTool(
+  'metabase_dashboard_info',
+  {
     title: 'Obtener detalles de Dashboard',
     description: 'Obtiene información detallada de un dashboard específico incluyendo sus cards',
-  },
-  inputSchema: z.object({
+    inputSchema: {
       dashboard_id: z.number().describe('ID del dashboard'),
-  }),
-  outputSchema: z.any(),
-  handler: async (input) => {
-    const { dashboard_id } = input;
-    const dashboard = await metabaseFetch(`/api/dashboard/${dashboard_id}`);
-    return dashboard;
     },
-});
+    outputSchema: z.any()
+  },
+  async ({ dashboard_id }) => {
+    try {
+      const dashboard = await metabaseFetch(`/api/dashboard/${dashboard_id}`);
+      return {
+        content: [{ type: 'text', text: JSON.stringify(dashboard, null, 2) }],
+        structuredContent: dashboard
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Error desconocido';
+      return {
+        content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+        isError: true
+      };
+    }
+  }
+);
 
 // ==================== Servidor Express ====================
 const app = express();
@@ -332,12 +429,31 @@ app.get('/health', (req, res) => {
 
 // Endpoint MCP (Traefik hace StripPrefix de /mcp)
 app.post('/', async (req, res) => {
+  try {
     const transport = new StreamableHTTPServerTransport({
-    endpoint: '/',
-    sessionIdGenerator: () => Math.random().toString(36).substring(7),
+      sessionIdGenerator: undefined,
+      enableJsonResponse: true
     });
 
-  await transport.handleRequest(req, res, server);
+    res.on('close', () => {
+      transport.close();
+    });
+
+    await server.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  } catch (error) {
+    console.error('Error handling MCP request:', error);
+    if (!res.headersSent) {
+      res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+          code: -32603,
+          message: 'Internal server error'
+        },
+        id: null
+      });
+    }
+  }
 });
 
 // Iniciar servidor