@hypequery/mcp 0.5.5 → 0.7.0

package/dist/index.js

@@ -5,9 +5,15 @@
  * Exposes datasets and metrics to AI agents via MCP tools.
  */
 export { HypequeryMCPServer, createMCPServer } from './server.js';
+export { HypequeryMCPExecutor, createMCPExecutor, } from './executor.js';
+export { HypequeryMCPDiscoveryExecutor, createMCPDiscoveryExecutor, } from './discovery-executor.js';
+export { HypequeryMCPProtocolServer, createMCPProtocolServer, } from './protocol-server.js';
+export { connectMCPServerStdio, startStdioMCPServer } from './stdio.js';
 export { listDatasetsTool } from './tools/list-datasets.js';
-export { getDatasetSchemaTool } from './tools/introspect.js';
+export { getDatasetSchemaTool, getTrustedDatasetSchema } from './tools/introspect.js';
 export { queryMetricTool } from './tools/query-metric.js';
 export { queryDatasetTool } from './tools/query-dataset.js';
 export { datasetGuidePrompt } from './prompts/dataset-guide.js';
-export { MAX_QUERY_LIMIT, DEFAULT_QUERY_LIMIT } from './types.js';
+export { MCPExecutionBudgetError, MCPToolError, classifyMCPToolError, formatMCPToolError, } from './errors.js';
+export { MAX_QUERY_LIMIT, DEFAULT_QUERY_LIMIT, MAX_QUERY_OFFSET, MAX_QUERY_DIMENSIONS, MAX_QUERY_MEASURES, MAX_QUERY_FILTERS, MAX_QUERY_ORDER_BY, DEFAULT_QUERY_TIMEOUT_MS, MAX_QUERY_TIMEOUT_MS, DEFAULT_RESPONSE_BYTES, MAX_RESPONSE_BYTES, } from './types.js';
+export { MCP_PACKAGE_VERSION } from './version.js';

package/dist/protocol-server.d.ts

@@ -0,0 +1,26 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { MCPToolExecutor } from './executor.js';
+export interface MCPProtocolServerOptions {
+    executor: MCPToolExecutor;
+    name?: string;
+    version?: string;
+}
+/**
+ * MCP protocol adapter for a transport-neutral Hypequery executor.
+ *
+ * The caller owns the transport. The same server can therefore be connected to
+ * stdio, an in-memory pair, or a hosted transport without changing tool logic.
+ */
+export declare class HypequeryMCPProtocolServer {
+    private readonly server;
+    protected readonly executor: MCPToolExecutor;
+    constructor(options: MCPProtocolServerOptions);
+    private setupHandlers;
+    getManifestHash(): string;
+    connect(transport: Transport): Promise<void>;
+    close(): Promise<void>;
+    /** Alias retained for the existing Hypequery MCP server lifecycle. */
+    stop(): Promise<void>;
+}
+export declare function createMCPProtocolServer(options: MCPProtocolServerOptions): HypequeryMCPProtocolServer;
+//# sourceMappingURL=protocol-server.d.ts.map

package/dist/protocol-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-server.d.ts","sourceRoot":"","sources":["../src/protocol-server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,+CAA+C,CAAC;AAO/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGrD,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,eAAe,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,qBAAa,0BAA0B;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;gBAEjC,OAAO,EAAE,wBAAwB;IAkB7C,OAAO,CAAC,aAAa;IAkBrB,eAAe,IAAI,MAAM;IAInB,OAAO,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,sEAAsE;IAChE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,GAChC,0BAA0B,CAE5B"}

package/dist/protocol-server.js

@@ -0,0 +1,48 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { MCP_PACKAGE_VERSION } from './version.js';
+/**
+ * MCP protocol adapter for a transport-neutral Hypequery executor.
+ *
+ * The caller owns the transport. The same server can therefore be connected to
+ * stdio, an in-memory pair, or a hosted transport without changing tool logic.
+ */
+export class HypequeryMCPProtocolServer {
+    server;
+    executor;
+    constructor(options) {
+        this.executor = options.executor;
+        this.server = new Server({
+            name: options.name ?? 'hypequery-mcp-server',
+            version: options.version ?? MCP_PACKAGE_VERSION,
+        }, {
+            capabilities: {
+                tools: {},
+                prompts: {},
+            },
+        });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => (this.executor.listTools()));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => (this.executor.callTool(request.params.name, request.params.arguments, extra?.signal)));
+        this.server.setRequestHandler(ListPromptsRequestSchema, async () => (this.executor.listPrompts()));
+        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => (this.executor.getPrompt(request.params.name, request.params.arguments)));
+    }
+    getManifestHash() {
+        return this.executor.getManifestHash();
+    }
+    async connect(transport) {
+        await this.server.connect(transport);
+    }
+    async close() {
+        await this.server.close();
+    }
+    /** Alias retained for the existing Hypequery MCP server lifecycle. */
+    async stop() {
+        await this.close();
+    }
+}
+export function createMCPProtocolServer(options) {
+    return new HypequeryMCPProtocolServer(options);
+}

package/dist/server.d.ts

@@ -1,56 +1,27 @@
 /**
- * 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 type { DatasetClient } from '@hypequery/datasets';
-import type { DatasetRegistry } from './types.js';
-export interface MCPServerConfig {
-    /**
-     * Dataset registry - map of dataset names to instances
-     */
-    datasets: DatasetRegistry;
-    /**
-     * Semantic analytics for running metric and dataset queries
-     */
-    analytics: DatasetClient;
-    /**
-     * Server name (shown in MCP client)
-     */
-    name?: string;
-    /**
-     * Server version
-     */
-    version?: string;
-    /**
-     * Trusted tenant id used to scope tenant-keyed datasets.
-     */
-    tenantId?: string;
-    /**
-     * Include generated SQL in query tool responses.
-     *
-     * Defaults to false so agent-facing responses do not expose SQL text unless
-     * explicitly enabled for trusted debugging.
-     */
-    includeSql?: boolean;
-}
-export declare class HypequeryMCPServer {
-    private server;
-    private config;
+import { type MCPServerConfig } from './executor.js';
+import { HypequeryMCPProtocolServer } from './protocol-server.js';
+export type { MCPServerConfig } from './executor.js';
+export declare class HypequeryMCPServer extends HypequeryMCPProtocolServer {
     constructor(config: MCPServerConfig);
-    private setupHandlers;
     /**
-     * Start the MCP server with stdio transport
+     * Start with the legacy stdio transport.
+     *
+     * @deprecated Prefer connect(transport) or startStdioMCPServer(config).
      */
     start(): Promise<void>;
-    /**
-     * Stop the MCP server
-     */
-    stop(): Promise<void>;
 }
 /**
- * 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 declare function createMCPServer(config: MCPServerConfig): Promise<HypequeryMCPServer>;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC;IAE1B;;OAEG;IACH,SAAS,EAAE,aAAa,CAAC;IAEzB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAiCD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,eAAe;IAoBnC,OAAO,CAAC,aAAa;IA2OrB;;OAEG;IACG,KAAK;IAQX;;OAEG;IACG,IAAI;CAGX;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAI1F"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAwB,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,qBAAa,kBAAmB,SAAQ,0BAA0B;gBACpD,MAAM,EAAE,eAAe;IASnC;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAI7B;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAI1F"}

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"}