@lightdash-tools/mcp 0.1.0

package/src/http.ts

@@ -0,0 +1,184 @@
+/**
+ * MCP server entrypoint (Streamable HTTP). Use LIGHTDASH_URL, LIGHTDASH_API_KEY.
+ * Optional: MCP_AUTH_ENABLED, MCP_API_KEY. Logging: stderr only.
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { getClient } from './config.js';
+import { registerTools } from './tools/index.js';
+
+const MCP_PATH = '/mcp';
+const PORT = Number(process.env.MCP_HTTP_PORT ?? '3100');
+
+const sessionMap = new Map<string, StreamableHTTPServerTransport>();
+const sharedClient = getClient();
+
+function isAuthEnabled(): boolean {
+  const v = process.env.MCP_AUTH_ENABLED;
+  return v === '1' || v === 'true' || v === 'yes';
+}
+
+function getExpectedApiKey(): string | undefined {
+  return process.env.MCP_API_KEY;
+}
+
+function authMiddleware(req: IncomingMessage, res: ServerResponse): boolean {
+  if (!isAuthEnabled()) return true;
+  const expected = getExpectedApiKey();
+  if (!expected) {
+    console.error('MCP_AUTH_ENABLED is set but MCP_API_KEY is missing');
+    res
+      .writeHead(500, { 'Content-Type': 'application/json' })
+      .end(JSON.stringify({ error: 'Server auth misconfiguration' }));
+    return false;
+  }
+  const bearer = req.headers.authorization;
+  const apiKey = req.headers['x-api-key'];
+  const token =
+    typeof bearer === 'string' && bearer.startsWith('Bearer ') ? bearer.slice(7).trim() : undefined;
+  const key = typeof apiKey === 'string' ? apiKey.trim() : undefined;
+  const provided = token ?? key;
+  if (!provided || provided !== expected) {
+    res
+      .writeHead(401, { 'Content-Type': 'application/json' })
+      .end(JSON.stringify({ error: 'Unauthorized' }));
+    return false;
+  }
+  return true;
+}
+
+function createSessionTransport(): StreamableHTTPServerTransport {
+  const server = new McpServer({ name: 'lightdash-mcp', version: '1.0.0' });
+  registerTools(server, sharedClient);
+
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID(),
+    onsessioninitialized: (sessionId) => {
+      sessionMap.set(sessionId, transport);
+    },
+    onsessionclosed: (sessionId) => {
+      sessionMap.delete(sessionId);
+    },
+  });
+
+  server.connect(transport).catch((err) => {
+    console.error('MCP server connect error:', err);
+  });
+
+  return transport;
+}
+
+function readBody(req: IncomingMessage): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk) => chunks.push(chunk));
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function parseJsonBody(buffer: Buffer): unknown {
+  const text = buffer.toString('utf-8');
+  if (!text.trim()) return undefined;
+  return JSON.parse(text) as unknown;
+}
+
+function isInitializeMessage(body: unknown): boolean {
+  if (body === undefined) return false;
+  const msg = Array.isArray(body) ? body[0] : body;
+  return (
+    typeof msg === 'object' &&
+    msg !== null &&
+    'method' in msg &&
+    (msg as { method?: string }).method === 'initialize'
+  );
+}
+
+async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  if (!authMiddleware(req, res)) return;
+
+  const url = req.url ?? '';
+  const path = url.split('?')[0];
+  if (path !== MCP_PATH) {
+    res
+      .writeHead(404, { 'Content-Type': 'application/json' })
+      .end(JSON.stringify({ error: 'Not Found' }));
+    return;
+  }
+
+  const sessionId = req.headers['mcp-session-id'];
+  const sid =
+    typeof sessionId === 'string' ? sessionId : Array.isArray(sessionId) ? sessionId[0] : undefined;
+
+  if (req.method === 'POST') {
+    const raw = await readBody(req);
+    const body = raw.length > 0 ? parseJsonBody(raw) : undefined;
+
+    if (sid) {
+      const transport = sessionMap.get(sid);
+      if (!transport) {
+        res
+          .writeHead(404, { 'Content-Type': 'application/json' })
+          .end(JSON.stringify({ error: 'Session not found' }));
+        return;
+      }
+      await transport.handleRequest(req, res, body);
+      return;
+    }
+
+    if (body !== undefined && isInitializeMessage(body)) {
+      const transport = createSessionTransport();
+      await transport.handleRequest(req, res, body);
+      return;
+    }
+
+    res.writeHead(400, { 'Content-Type': 'application/json' }).end(
+      JSON.stringify({
+        error: 'Bad Request: Mcp-Session-Id required for non-initialize requests',
+      }),
+    );
+    return;
+  }
+
+  if (req.method === 'GET' || req.method === 'DELETE') {
+    if (!sid) {
+      res
+        .writeHead(400, { 'Content-Type': 'application/json' })
+        .end(JSON.stringify({ error: 'Bad Request: Mcp-Session-Id required' }));
+      return;
+    }
+    const transport = sessionMap.get(sid);
+    if (!transport) {
+      res
+        .writeHead(404, { 'Content-Type': 'application/json' })
+        .end(JSON.stringify({ error: 'Session not found' }));
+      return;
+    }
+    await transport.handleRequest(req, res);
+    return;
+  }
+
+  res.writeHead(405, { Allow: 'GET, POST, DELETE' }).end();
+}
+
+function main(): void {
+  const server = createServer((req, res) => {
+    handleRequest(req, res).catch((err) => {
+      console.error('MCP HTTP handler error:', err);
+      if (!res.headersSent) {
+        res
+          .writeHead(500, { 'Content-Type': 'application/json' })
+          .end(JSON.stringify({ error: 'Internal Server Error' }));
+      }
+    });
+  });
+
+  server.listen(PORT, () => {
+    console.error(`Lightdash MCP server listening on http://localhost:${PORT}${MCP_PATH}`);
+  });
+}
+
+main();

package/src/index.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from 'vitest';
+import { registerTools } from './tools';
+
+describe('MCP tools', () => {
+  it('registerTools is a function', () => {
+    expect(typeof registerTools).toBe('function');
+  });
+});

package/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * MCP server entrypoint (Stdio). Use LIGHTDASH_URL and LIGHTDASH_API_KEY.
+ * Logging: stderr only (stdout is JSON-RPC).
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { getClient } from './config';
+import { registerTools } from './tools';
+
+async function main(): Promise<void> {
+  const client = getClient();
+  const server = new McpServer({
+    name: 'lightdash-mcp',
+    version: '1.0.0',
+  });
+
+  registerTools(server, client);
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Lightdash MCP server running on stdio');
+}
+
+main().catch((err) => {
+  console.error('Fatal:', err);
+  process.exit(1);
+});

package/src/tools/charts.ts

@@ -0,0 +1,85 @@
+/**
+ * MCP tools: charts (list, charts-as-code list and upsert).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT, WRITE_IDEMPOTENT } from './shared.js';
+
+export function registerChartTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_charts',
+    {
+      title: 'List charts',
+      description: 'List charts in a project',
+      inputSchema: { projectUuid: z.string().describe('Project UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ projectUuid }: { projectUuid: string }) => {
+      const charts = await c.v1.charts.listCharts(projectUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(charts, null, 2) }] };
+    }),
+  );
+  registerToolSafe(
+    server,
+    'list_charts_as_code',
+    {
+      title: 'List charts as code',
+      description: 'Get charts in code representation for a project (for charts-as-code workflows)',
+      inputSchema: {
+        projectUuid: z.string().describe('Project UUID'),
+        ids: z.array(z.string()).optional().describe('Optional chart IDs (slugs) to filter'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({ projectUuid, ids }: { projectUuid: string; ids?: string[] }) => {
+          const result = await c.v1.charts.getChartsAsCode(projectUuid, { ids });
+          return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        },
+    ),
+  );
+  registerToolSafe(
+    server,
+    'upsert_chart_as_code',
+    {
+      title: 'Upsert chart as code',
+      description: 'Create or update a chart from its code representation (by slug)',
+      inputSchema: {
+        projectUuid: z.string().describe('Project UUID'),
+        slug: z.string().describe('Chart slug'),
+        chart: z
+          .record(z.string(), z.unknown())
+          .describe('Chart-as-code payload (name, metricQuery, chartConfig, etc.)'),
+      },
+      annotations: WRITE_IDEMPOTENT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({
+          projectUuid,
+          slug,
+          chart,
+        }: {
+          projectUuid: string;
+          slug: string;
+          chart: Record<string, unknown>;
+        }) => {
+          type UpsertChartBody = Parameters<
+            LightdashClient['v1']['charts']['upsertChartAsCode']
+          >[2];
+          const result = await c.v1.charts.upsertChartAsCode(
+            projectUuid,
+            slug,
+            chart as UpsertChartBody,
+          );
+          return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        },
+    ),
+  );
+}

package/src/tools/dashboards.ts

@@ -0,0 +1,25 @@
+/**
+ * MCP tools: dashboards (list).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+export function registerDashboardTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_dashboards',
+    {
+      title: 'List dashboards',
+      description: 'List dashboards in a project',
+      inputSchema: { projectUuid: z.string().describe('Project UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ projectUuid }: { projectUuid: string }) => {
+      const dashboards = await c.v1.dashboards.listDashboards(projectUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(dashboards, null, 2) }] };
+    }),
+  );
+}

package/src/tools/explores.ts

@@ -0,0 +1,46 @@
+/**
+ * MCP tools: explores (list, get).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+export function registerExploresTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_explores',
+    {
+      title: 'List explores',
+      description: 'List all explores in a project',
+      inputSchema: { projectUuid: z.string().describe('Project UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ projectUuid }: { projectUuid: string }) => {
+      const explores = await c.v1.explores.listExplores(projectUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(explores, null, 2) }] };
+    }),
+  );
+  registerToolSafe(
+    server,
+    'get_explore',
+    {
+      title: 'Get explore',
+      description: 'Get an explore by project UUID and explore ID',
+      inputSchema: {
+        projectUuid: z.string().describe('Project UUID'),
+        exploreId: z.string().describe('Explore ID'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({ projectUuid, exploreId }: { projectUuid: string; exploreId: string }) => {
+          const explore = await c.v1.explores.getExplore(projectUuid, exploreId);
+          return { content: [{ type: 'text', text: JSON.stringify(explore, null, 2) }] };
+        },
+    ),
+  );
+}

package/src/tools/groups.ts

@@ -0,0 +1,49 @@
+/**
+ * MCP tools: groups (list, get).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+type ListGroupsParams = {
+  page?: number;
+  pageSize?: number;
+  searchQuery?: string;
+};
+
+export function registerGroupTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_groups',
+    {
+      title: 'List groups',
+      description: 'List organization groups (one page)',
+      inputSchema: {
+        page: z.number().optional().describe('Page number'),
+        pageSize: z.number().optional().describe('Page size'),
+        searchQuery: z.string().optional().describe('Search query'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async (params: ListGroupsParams) => {
+      const result = await c.v1.groups.listGroups(params ?? {});
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+    }),
+  );
+  registerToolSafe(
+    server,
+    'get_group',
+    {
+      title: 'Get group',
+      description: 'Get a group by UUID',
+      inputSchema: { groupUuid: z.string().describe('Group UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ groupUuid }: { groupUuid: string }) => {
+      const group = await c.v1.groups.getGroup(groupUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(group, null, 2) }] };
+    }),
+  );
+}

package/src/tools/index.ts

@@ -0,0 +1,25 @@
+/**
+ * MCP tool registration: barrel that delegates to domain modules.
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { registerProjectTools } from './projects.js';
+import { registerChartTools } from './charts.js';
+import { registerDashboardTools } from './dashboards.js';
+import { registerSpaceTools } from './spaces.js';
+import { registerUserTools } from './users.js';
+import { registerGroupTools } from './groups.js';
+import { registerQueryTools } from './query.js';
+import { registerExploresTools } from './explores.js';
+
+export function registerTools(server: McpServer, client: LightdashClient): void {
+  registerProjectTools(server, client);
+  registerChartTools(server, client);
+  registerDashboardTools(server, client);
+  registerSpaceTools(server, client);
+  registerUserTools(server, client);
+  registerGroupTools(server, client);
+  registerQueryTools(server, client);
+  registerExploresTools(server, client);
+}

package/src/tools/projects.ts

@@ -0,0 +1,39 @@
+/**
+ * MCP tools: projects (list, get).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+export function registerProjectTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_projects',
+    {
+      title: 'List projects',
+      description: 'List all projects in the current organization',
+      inputSchema: {},
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, () => async () => {
+      const projects = await client.v1.projects.listProjects();
+      return { content: [{ type: 'text', text: JSON.stringify(projects, null, 2) }] };
+    }),
+  );
+  registerToolSafe(
+    server,
+    'get_project',
+    {
+      title: 'Get project',
+      description: 'Get a project by UUID',
+      inputSchema: { projectUuid: z.string().describe('Project UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ projectUuid }: { projectUuid: string }) => {
+      const project = await c.v1.projects.getProject(projectUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(project, null, 2) }] };
+    }),
+  );
+}

package/src/tools/query.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP tools: query (compile).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+export function registerQueryTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'compile_query',
+    {
+      title: 'Compile query',
+      description: 'Compile a metric query for an explore without executing it',
+      inputSchema: {
+        projectUuid: z.string().describe('Project UUID'),
+        exploreId: z.string().describe('Explore ID'),
+        metricQuery: z
+          .record(z.string(), z.unknown())
+          .describe('Metric query object (dimensions, metrics, filters, etc.)'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({
+          projectUuid,
+          exploreId,
+          metricQuery,
+        }: {
+          projectUuid: string;
+          exploreId: string;
+          metricQuery: Record<string, unknown>;
+        }) => {
+          const result = await c.v1.query.compileQuery(
+            projectUuid,
+            exploreId,
+            metricQuery as never,
+          );
+          return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+        },
+    ),
+  );
+}

package/src/tools/shared.ts

@@ -0,0 +1,101 @@
+/**
+ * Shared types and helpers for MCP tool registration.
+ */
+
+import type { LightdashClient } from '@lightdash-tools/client';
+import type { z } from 'zod';
+import { toMcpErrorMessage } from '../errors.js';
+
+/** Prefix for all MCP tool names (disambiguation when multiple servers are connected). */
+export const TOOL_PREFIX = 'lightdash_tools__';
+
+export type TextContent = {
+  content: Array<{ type: 'text'; text: string }>;
+};
+
+/** Tool handler type used to avoid deep instantiation with SDK/Zod. Accepts (args, extra) for SDK compatibility. */
+export type ToolHandler = (args: unknown, extra?: unknown) => Promise<TextContent>;
+
+/** MCP tool annotations (hints for client display and approval). See MCP spec Tool annotations. */
+export type ToolAnnotations = {
+  title?: string;
+  readOnlyHint?: boolean;
+  destructiveHint?: boolean;
+  idempotentHint?: boolean;
+  openWorldHint?: boolean;
+};
+
+/** Options for registerTool; inputSchema typed as ZodRawShapeCompat for SDK compatibility. Pass annotations explicitly (e.g. READ_ONLY_DEFAULT or WRITE_IDEMPOTENT) for visibility. */
+export type ToolOptions = {
+  description: string;
+  inputSchema: Record<string, z.ZodTypeAny>;
+  title?: string;
+  annotations?: ToolAnnotations;
+};
+
+/** Preset: read-only, non-destructive, idempotent, closed-world. Use for list/get/compile tools. */
+export const READ_ONLY_DEFAULT: ToolAnnotations = {
+  readOnlyHint: true,
+  openWorldHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+};
+
+/** Preset: write, non-destructive, idempotent (e.g. upsert by slug). Use for create/update tools. */
+export const WRITE_IDEMPOTENT: ToolAnnotations = {
+  readOnlyHint: false,
+  openWorldHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+};
+
+/** Preset: write, destructive, non-idempotent. Use for delete/remove tools; clients should prompt for user confirmation. */
+export const WRITE_DESTRUCTIVE: ToolAnnotations = {
+  readOnlyHint: false,
+  openWorldHint: false,
+  destructiveHint: true,
+  idempotentHint: false,
+};
+
+/** Internal default for mergeAnnotations; READ_ONLY_DEFAULT is the exported preset. */
+const DEFAULT_ANNOTATIONS: ToolAnnotations = READ_ONLY_DEFAULT;
+
+type RegisterToolFn = (name: string, options: ToolOptions, handler: ToolHandler) => void;
+
+/** Merges per-tool annotations with defaults; per-tool values win. */
+function mergeAnnotations(overrides?: ToolAnnotations): ToolAnnotations {
+  return { ...DEFAULT_ANNOTATIONS, ...overrides };
+}
+
+/** Registers a tool with prefix and annotations. shortName is TOOL_PREFIX + shortName. Pass annotations explicitly (e.g. READ_ONLY_DEFAULT, WRITE_IDEMPOTENT, or WRITE_DESTRUCTIVE). */
+export function registerToolSafe(
+  server: unknown,
+  shortName: string,
+  options: ToolOptions,
+  handler: ToolHandler,
+): void {
+  const name = TOOL_PREFIX + shortName;
+  const annotations = mergeAnnotations(options.annotations);
+  const mergedOptions: ToolOptions = {
+    ...options,
+    title: options.title ?? options.annotations?.title,
+    annotations,
+  };
+  (server as { registerTool: RegisterToolFn }).registerTool(name, mergedOptions, handler);
+}
+
+export function wrapTool<T>(
+  client: LightdashClient,
+  fn: (client: LightdashClient) => (args: T) => Promise<TextContent>,
+): ToolHandler {
+  const handler = fn(client);
+  return async (args: unknown, extra?: unknown) => {
+    void extra;
+    try {
+      return await handler(args as T);
+    } catch (err) {
+      const text = toMcpErrorMessage(err);
+      return { content: [{ type: 'text', text }] };
+    }
+  };
+}

package/src/tools/spaces.ts

@@ -0,0 +1,46 @@
+/**
+ * MCP tools: spaces (list, get).
+ */
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LightdashClient } from '@lightdash-tools/client';
+import { z } from 'zod';
+import { wrapTool, registerToolSafe, READ_ONLY_DEFAULT } from './shared.js';
+
+export function registerSpaceTools(server: McpServer, client: LightdashClient): void {
+  registerToolSafe(
+    server,
+    'list_spaces',
+    {
+      title: 'List spaces',
+      description: 'List spaces in a project',
+      inputSchema: { projectUuid: z.string().describe('Project UUID') },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(client, (c) => async ({ projectUuid }: { projectUuid: string }) => {
+      const spaces = await c.v1.spaces.listSpacesInProject(projectUuid);
+      return { content: [{ type: 'text', text: JSON.stringify(spaces, null, 2) }] };
+    }),
+  );
+  registerToolSafe(
+    server,
+    'get_space',
+    {
+      title: 'Get space',
+      description: 'Get a space by project and space UUID',
+      inputSchema: {
+        projectUuid: z.string().describe('Project UUID'),
+        spaceUuid: z.string().describe('Space UUID'),
+      },
+      annotations: READ_ONLY_DEFAULT,
+    },
+    wrapTool(
+      client,
+      (c) =>
+        async ({ projectUuid, spaceUuid }: { projectUuid: string; spaceUuid: string }) => {
+          const space = await c.v1.spaces.getSpace(projectUuid, spaceUuid);
+          return { content: [{ type: 'text', text: JSON.stringify(space, null, 2) }] };
+        },
+    ),
+  );
+}