@hypequery/mcp 0.5.5 → 0.6.0

package/dist/server.js

@@ -1,286 +1,36 @@
 /**
- * MCP Server for Hypequery Semantic Layer
+ * Backwards-compatible Hypequery MCP server facade.
  *
- * Exposes datasets and metrics via Model Context Protocol (MCP)
- * for use with Claude Desktop, Cursor, and other MCP-compatible tools.
+ * New integrations can compose HypequeryMCPExecutor with
+ * HypequeryMCPProtocolServer and supply their own transport. Existing callers
+ * can continue to construct this class and call start() for stdio.
  */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { listDatasetsTool } from './tools/list-datasets.js';
-import { getDatasetSchemaTool } from './tools/introspect.js';
-import { queryMetricTool } from './tools/query-metric.js';
-import { queryDatasetTool } from './tools/query-dataset.js';
-import { datasetGuidePrompt } from './prompts/dataset-guide.js';
-function isRecord(value) {
-    return !!value && typeof value === 'object';
-}
-function getTenantKey(dataset) {
-    if (!isRecord(dataset)) {
-        return undefined;
-    }
-    const config = dataset.config;
-    const configTenantKey = isRecord(config) ? config.tenantKey : undefined;
-    const tenantKey = dataset.tenantKey ?? configTenantKey;
-    return typeof tenantKey === 'string' && tenantKey.length > 0 ? tenantKey : undefined;
-}
-function validateTenantConfig(config) {
-    if (config.tenantId) {
-        return;
-    }
-    const tenantScopedDatasets = Object.entries(config.datasets ?? {})
-        .filter(([, ds]) => getTenantKey(ds))
-        .map(([name]) => name);
-    if (tenantScopedDatasets.length > 0) {
-        throw new Error(`MCP server tenantId is required for tenant-scoped datasets: ${tenantScopedDatasets.join(', ')}`);
-    }
-}
-export class HypequeryMCPServer {
-    server;
-    config;
+import { HypequeryMCPExecutor } from './executor.js';
+import { HypequeryMCPProtocolServer } from './protocol-server.js';
+export class HypequeryMCPServer extends HypequeryMCPProtocolServer {
     constructor(config) {
-        validateTenantConfig(config);
-        this.config = config;
-        this.server = new Server({
-            name: config.name ?? 'hypequery-mcp-server',
-            version: config.version ?? '0.1.0',
-        }, {
-            capabilities: {
-                tools: {},
-                prompts: {},
-            },
-        });
-        this.setupHandlers();
-    }
-    setupHandlers() {
-        // List available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'list_datasets',
-                    description: 'List all available datasets in the semantic layer',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                {
-                    name: 'get_dataset_schema',
-                    description: 'Get the schema (dimensions, measures, named metrics, filters, relationships) for a specific dataset',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            dataset: {
-                                type: 'string',
-                                description: 'Name of the dataset to introspect',
-                            },
-                        },
-                        required: ['dataset'],
-                    },
-                },
-                {
-                    name: 'query_metric',
-                    description: 'Execute a metric query with optional dimensions, filters, time grain, and sorting',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            dataset: {
-                                type: 'string',
-                                description: 'Name of the dataset containing the metric',
-                            },
-                            metric: {
-                                type: 'string',
-                                description: 'Name of the metric to query',
-                            },
-                            dimensions: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Dimensions to group by (optional)',
-                            },
-                            filters: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        field: { type: 'string' },
-                                        operator: {
-                                            type: 'string',
-                                            enum: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'between', 'like']
-                                        },
-                                        value: {},
-                                    },
-                                    required: ['field', 'operator', 'value'],
-                                },
-                                description: 'Filters to apply (optional)',
-                            },
-                            grain: {
-                                type: 'string',
-                                enum: ['day', 'week', 'month', 'quarter', 'year'],
-                                description: 'Time grain for time-series queries (optional)',
-                            },
-                            orderBy: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        field: { type: 'string' },
-                                        direction: { type: 'string', enum: ['asc', 'desc'] },
-                                    },
-                                    required: ['field', 'direction'],
-                                },
-                                description: 'Sort order (optional)',
-                            },
-                            limit: {
-                                type: 'number',
-                                description: 'Maximum number of rows to return (optional)',
-                            },
-                            offset: {
-                                type: 'number',
-                                description: 'Number of rows to skip before returning results (optional)',
-                            },
-                        },
-                        required: ['dataset', 'metric'],
-                    },
-                },
-                {
-                    name: 'query_dataset',
-                    description: 'Execute an ad-hoc dataset query with custom dimensions and measures',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            dataset: {
-                                type: 'string',
-                                description: 'Name of the dataset to query',
-                            },
-                            dimensions: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Dimensions to select',
-                            },
-                            measures: {
-                                type: 'array',
-                                items: { type: 'string' },
-                                description: 'Measures to calculate',
-                            },
-                            filters: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        field: { type: 'string' },
-                                        operator: {
-                                            type: 'string',
-                                            enum: ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn', 'between', 'like']
-                                        },
-                                        value: {},
-                                    },
-                                    required: ['field', 'operator', 'value'],
-                                },
-                                description: 'Filters to apply (optional)',
-                            },
-                            grain: {
-                                type: 'string',
-                                enum: ['day', 'week', 'month', 'quarter', 'year'],
-                                description: 'Time grain for time-series queries (optional)',
-                            },
-                            orderBy: {
-                                type: 'array',
-                                items: {
-                                    type: 'object',
-                                    properties: {
-                                        field: { type: 'string' },
-                                        direction: { type: 'string', enum: ['asc', 'desc'] },
-                                    },
-                                    required: ['field', 'direction'],
-                                },
-                                description: 'Sort order (optional)',
-                            },
-                            limit: {
-                                type: 'number',
-                                description: 'Maximum number of rows to return (optional)',
-                            },
-                            offset: {
-                                type: 'number',
-                                description: 'Number of rows to skip before returning results (optional)',
-                            },
-                        },
-                        required: ['dataset'],
-                    },
-                },
-            ],
-        }));
-        // Handle tool calls
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'list_datasets':
-                        return await listDatasetsTool(this.config.datasets);
-                    case 'get_dataset_schema':
-                        return await getDatasetSchemaTool(this.config.datasets, args, { includeSql: this.config.includeSql });
-                    case 'query_metric':
-                        return await queryMetricTool(this.config.datasets, this.config.analytics, args, { tenantId: this.config.tenantId, includeSql: this.config.includeSql });
-                    case 'query_dataset':
-                        return await queryDatasetTool(this.config.datasets, this.config.analytics, args, { tenantId: this.config.tenantId, includeSql: this.config.includeSql });
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        });
-        // List available prompts
-        this.server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-            prompts: [
-                {
-                    name: 'dataset_guide',
-                    description: 'Guide for querying datasets with natural language',
-                    arguments: [
-                        {
-                            name: 'dataset',
-                            description: 'Name of the dataset to get guidance for',
-                            required: false,
-                        },
-                    ],
-                },
-            ],
-        }));
-        // Get prompt content
-        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            if (name === 'dataset_guide') {
-                return datasetGuidePrompt(this.config.datasets, args?.dataset);
-            }
-            throw new Error(`Unknown prompt: ${name}`);
+        const executor = new HypequeryMCPExecutor(config);
+        super({
+            executor,
+            name: config.name,
+            version: config.version,
         });
     }
     /**
-     * Start the MCP server with stdio transport
+     * Start with the legacy stdio transport.
+     *
+     * @deprecated Prefer connect(transport) or startStdioMCPServer(config).
      */
     async start() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Log to stderr (stdout is used for MCP protocol)
-        console.error('Hypequery MCP Server started');
-    }
-    /**
-     * Stop the MCP server
-     */
-    async stop() {
-        await this.server.close();
+        const { connectMCPServerStdio } = await import('./stdio.js');
+        await connectMCPServerStdio(this);
     }
 }
 /**
- * Create and start an MCP server
+ * Create and start a backwards-compatible stdio MCP server.
+ *
+ * @deprecated Prefer createMCPExecutor with createMCPProtocolServer, or
+ * startStdioMCPServer for an explicit stdio lifecycle.
  */
 export async function createMCPServer(config) {
     const server = new HypequeryMCPServer(config);

package/dist/stdio.d.ts

@@ -0,0 +1,8 @@
+import type { MCPServerConfig } from './executor.js';
+import type { HypequeryMCPProtocolServer } from './protocol-server.js';
+import { HypequeryMCPServer } from './server.js';
+/** Connect an existing Hypequery MCP server to the stdio transport. */
+export declare function connectMCPServerStdio(server: HypequeryMCPProtocolServer): Promise<void>;
+/** Create and start the backwards-compatible stdio MCP server. */
+export declare function startStdioMCPServer(config: MCPServerConfig): Promise<HypequeryMCPServer>;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../src/stdio.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEjD,uEAAuE;AACvE,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,0BAA0B,GACjC,OAAO,CAAC,IAAI,CAAC,CAKf;AAED,kEAAkE;AAClE,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,kBAAkB,CAAC,CAI7B"}

package/dist/stdio.js

@@ -0,0 +1,14 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { HypequeryMCPServer } from './server.js';
+/** Connect an existing Hypequery MCP server to the stdio transport. */
+export async function connectMCPServerStdio(server) {
+    await server.connect(new StdioServerTransport());
+    // MCP stdio owns stdout, so lifecycle logging must use stderr.
+    console.error('Hypequery MCP Server started');
+}
+/** Create and start the backwards-compatible stdio MCP server. */
+export async function startStdioMCPServer(config) {
+    const server = new HypequeryMCPServer(config);
+    await connectMCPServerStdio(server);
+    return server;
+}

package/dist/tools/args.d.ts

@@ -7,12 +7,12 @@ export declare const queryMetricArgsSchema: z.ZodObject<{
         operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte", "in", "notIn", "between", "like"]>;
         value: z.ZodEffects<z.ZodAny, any, any>;
     }, "strict", z.ZodTypeAny, {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }, {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }>, "many">>;
     grain: z.ZodOptional<z.ZodEnum<["day", "week", "month", "quarter", "year"]>>;
@@ -32,14 +32,14 @@ export declare const queryMetricArgsSchema: z.ZodObject<{
     dataset: z.ZodOptional<z.ZodString>;
     metric: z.ZodOptional<z.ZodString>;
 }, "strict", z.ZodTypeAny, {
-    dataset?: string | undefined;
-    metric?: string | undefined;
     dimensions?: string[] | undefined;
     filters?: {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }[] | undefined;
+    metric?: string | undefined;
+    dataset?: string | undefined;
     grain?: "day" | "week" | "month" | "quarter" | "year" | undefined;
     orderBy?: {
         field: string;
@@ -48,14 +48,14 @@ export declare const queryMetricArgsSchema: z.ZodObject<{
     limit?: number | undefined;
     offset?: number | undefined;
 }, {
-    dataset?: string | undefined;
-    metric?: string | undefined;
     dimensions?: string[] | undefined;
     filters?: {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }[] | undefined;
+    metric?: string | undefined;
+    dataset?: string | undefined;
     grain?: "day" | "week" | "month" | "quarter" | "year" | undefined;
     orderBy?: {
         field: string;
@@ -71,12 +71,12 @@ export declare const queryDatasetArgsSchema: z.ZodObject<{
         operator: z.ZodEnum<["eq", "neq", "gt", "gte", "lt", "lte", "in", "notIn", "between", "like"]>;
         value: z.ZodEffects<z.ZodAny, any, any>;
     }, "strict", z.ZodTypeAny, {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }, {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }>, "many">>;
     grain: z.ZodOptional<z.ZodEnum<["day", "week", "month", "quarter", "year"]>>;
@@ -96,13 +96,14 @@ export declare const queryDatasetArgsSchema: z.ZodObject<{
     dataset: z.ZodOptional<z.ZodString>;
     measures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strict", z.ZodTypeAny, {
-    dataset?: string | undefined;
     dimensions?: string[] | undefined;
     filters?: {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }[] | undefined;
+    measures?: string[] | undefined;
+    dataset?: string | undefined;
     grain?: "day" | "week" | "month" | "quarter" | "year" | undefined;
     orderBy?: {
         field: string;
@@ -110,15 +111,15 @@ export declare const queryDatasetArgsSchema: z.ZodObject<{
     }[] | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    measures?: string[] | undefined;
 }, {
-    dataset?: string | undefined;
     dimensions?: string[] | undefined;
     filters?: {
-        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         field: string;
+        operator: "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "notIn" | "between" | "like";
         value?: any;
     }[] | undefined;
+    measures?: string[] | undefined;
+    dataset?: string | undefined;
     grain?: "day" | "week" | "month" | "quarter" | "year" | undefined;
     orderBy?: {
         field: string;
@@ -126,7 +127,6 @@ export declare const queryDatasetArgsSchema: z.ZodObject<{
     }[] | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
-    measures?: string[] | undefined;
 }>;
 export declare function parseToolArgs<T>(schema: z.ZodType<T>, toolName: string, args: unknown): T;
 export declare function toMetricFilters(filters?: Array<{

package/dist/tools/args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/tools/args.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAuBnF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAWH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CAMzF;AAED,wBAAgB,eAAe,CAC7B,OAAO,GAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAM,GAC1F,YAAY,EAAE,CAMhB"}
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/tools/args.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAA6B,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AA+BnF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAWH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,CASzF;AAED,wBAAgB,eAAe,CAC7B,OAAO,GAAE,KAAK,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAM,GAC1F,YAAY,EAAE,CAMhB"}

package/dist/tools/args.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { SEMANTIC_FILTER_OPERATORS } from '@hypequery/datasets';
-import { MAX_QUERY_LIMIT } from '../types.js';
+import { MCPToolError } from '../errors.js';
+import { MAX_QUERY_DIMENSIONS, MAX_QUERY_FILTERS, MAX_QUERY_LIMIT, MAX_QUERY_MEASURES, MAX_QUERY_OFFSET, MAX_QUERY_ORDER_BY, } from '../types.js';
 const filterSchema = z.object({
     field: z.string().min(1),
     operator: z.enum(SEMANTIC_FILTER_OPERATORS),
@@ -11,12 +12,12 @@ const orderBySchema = z.object({
     direction: z.enum(['asc', 'desc']),
 }).strict();
 const baseQuerySchema = z.object({
-    dimensions: z.array(z.string().min(1)).optional(),
-    filters: z.array(filterSchema).optional(),
+    dimensions: z.array(z.string().min(1)).max(MAX_QUERY_DIMENSIONS).optional(),
+    filters: z.array(filterSchema).max(MAX_QUERY_FILTERS).optional(),
     grain: z.enum(['day', 'week', 'month', 'quarter', 'year']).optional(),
-    orderBy: z.array(orderBySchema).optional(),
-    limit: z.number().int().nonnegative().max(MAX_QUERY_LIMIT).optional(),
-    offset: z.number().int().nonnegative().optional(),
+    orderBy: z.array(orderBySchema).max(MAX_QUERY_ORDER_BY).optional(),
+    limit: z.number().int().positive().max(MAX_QUERY_LIMIT).optional(),
+    offset: z.number().int().nonnegative().max(MAX_QUERY_OFFSET).optional(),
 }).strict();
 export const queryMetricArgsSchema = baseQuerySchema.extend({
     dataset: z.string().min(1).optional(),
@@ -24,7 +25,7 @@ export const queryMetricArgsSchema = baseQuerySchema.extend({
 });
 export const queryDatasetArgsSchema = baseQuerySchema.extend({
     dataset: z.string().min(1).optional(),
-    measures: z.array(z.string().min(1)).optional(),
+    measures: z.array(z.string().min(1)).max(MAX_QUERY_MEASURES).optional(),
 });
 function formatZodError(error) {
     return error.issues
@@ -37,7 +38,7 @@ function formatZodError(error) {
 export function parseToolArgs(schema, toolName, args) {
     const result = schema.safeParse(args);
     if (!result.success) {
-        throw new Error(`Invalid ${toolName} arguments: ${formatZodError(result.error)}`);
+        throw new MCPToolError('MCP_INVALID_ARGUMENTS', `Invalid ${toolName} arguments: ${formatZodError(result.error)}`);
     }
     return result.data;
 }

package/dist/tools/introspect.d.ts

@@ -1,9 +1,11 @@
+/** Agent-safe dataset discovery and separately authorized trusted debugging. */
+import { type TrustedDebugCatalogAuthorization } from '@hypequery/datasets';
+import type { DatasetRegistry, MCPToolResponse, SchemaToolOptions } from '../types.js';
+export declare function getDatasetSchemaTool(datasets: DatasetRegistry, args: unknown, _options?: SchemaToolOptions): Promise<MCPToolResponse>;
 /**
- * Get Dataset Schema Tool
- *
- * Returns the complete schema for a dataset including dimensions, measures,
- * named metrics, filters, and relationships.
+ * Physical catalog diagnostics for a caller that has already passed a
+ * separate authorization check. This projection is intentionally not
+ * registered as an agent-facing MCP tool.
  */
-import type { DatasetRegistry, MCPToolResponse, SchemaToolOptions } from '../types.js';
-export declare function getDatasetSchemaTool(datasets: DatasetRegistry, args: unknown, options?: SchemaToolOptions): Promise<MCPToolResponse>;
+export declare function getTrustedDatasetSchema(datasets: DatasetRegistry, args: unknown, authorization: TrustedDebugCatalogAuthorization): Promise<unknown>;
 //# sourceMappingURL=introspect.d.ts.map

package/dist/tools/introspect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../src/tools/introspect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EAOf,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAMrB,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,eAAe,CAAC,CAuL1B"}
+{"version":3,"file":"introspect.d.ts","sourceRoot":"","sources":["../../src/tools/introspect.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAEhF,OAAO,EAML,KAAK,gCAAgC,EACtC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EACV,eAAe,EAEf,eAAe,EACf,iBAAiB,EAClB,MAAM,aAAa,CAAC;AAkBrB,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,OAAO,EACb,QAAQ,GAAE,iBAAsB,GAC/B,OAAO,CAAC,eAAe,CAAC,CAuB1B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,gCAAgC,GAC9C,OAAO,CAAC,OAAO,CAAC,CAclB"}