@kepler.gl/mcp 0.0.0-stage → 3.3.0-alpha.19

package/dist/cjs/server/stdio.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * `kepler-mcp` — a stdio MCP server for the kepler.gl map surface.
+ *
+ * The agent starts this process (it speaks MCP on stdin/stdout); the process
+ * also listens for the map page on a loopback WebSocket. It prints a URL that
+ * carries the one-time token — open that URL and the page connects, after which
+ * every map.* tool call executes against the live map.
+ *
+ * stdout belongs to the MCP protocol: every log line here goes to stderr.
+ */
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _nodeFs = require("node:fs");
+var _nodePath = require("node:path");
+var _index = require("@modelcontextprotocol/sdk/server/index.js");
+var _stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _bridgeServer = require("./bridge-server");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var DEFAULT_MAP_URL = 'http://localhost:8080';
+function readVersion() {
+  if (typeof __dirname === 'undefined') return '0.0.0';
+  var directory = __dirname;
+  // Walk up until the package manifest is found, so this works both from src/
+  // (babel-node, tests) and from dist/cjs/server (the published bin).
+  for (var depth = 0; depth < 5; depth++) {
+    try {
+      var manifest = JSON.parse((0, _nodeFs.readFileSync)((0, _nodePath.join)(directory, 'package.json'), 'utf8'));
+      if (manifest.name === '@kepler.gl/mcp') return manifest.version;
+    } catch (_unused) {
+      // no manifest at this level — keep walking
+    }
+    directory = (0, _nodePath.dirname)(directory);
+  }
+  return '0.0.0';
+}
+function usage() {
+  return ['Usage: kepler-mcp [--port <n>] [--host <h>] [--map-url <url>]', '', 'Runs a stdio MCP server for the kepler.gl map surface and waits for a', 'kepler.gl page to connect over a loopback WebSocket.', '', '  --port <n>       WebSocket port for the page (default 8765)', '  --host <h>       loopback host to bind (default 127.0.0.1)', "  --map-url <url>  page URL printed with the token (default ".concat(DEFAULT_MAP_URL, ")")].join('\n');
+}
+function parseArgs(argv) {
+  var options = {};
+  for (var i = 0; i < argv.length; i++) {
+    var arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--port') {
+      var value = Number(argv[++i]);
+      if (!Number.isInteger(value) || value < 0 || value > 65535) {
+        throw new Error("Invalid --port value: ".concat(argv[i]));
+      }
+      options.port = value;
+    } else if (arg === '--host') {
+      options.host = argv[++i];
+    } else if (arg === '--map-url') {
+      options.mapUrl = argv[++i];
+    } else {
+      throw new Error("Unknown argument: ".concat(arg));
+    }
+  }
+  return options;
+}
+function main() {
+  return _main.apply(this, arguments);
+}
+function _main() {
+  _main = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+    var options, bridge, started, server, shutdown;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          options = parseArgs(process.argv.slice(2));
+          if (!options.help) {
+            _context4.next = 4;
+            break;
+          }
+          console.error(usage());
+          return _context4.abrupt("return");
+        case 4:
+          bridge = new _bridgeServer.KeplerMcpBridge(options);
+          _context4.next = 7;
+          return bridge.start();
+        case 7:
+          started = _context4.sent;
+          server = new _index.Server({
+            name: 'kepler-mcp',
+            version: readVersion()
+          }, {
+            capabilities: {
+              tools: {}
+            }
+          });
+          server.setRequestHandler(_types.ListToolsRequestSchema, /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+            return _regenerator["default"].wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  return _context.abrupt("return", {
+                    tools: bridge.getTools().map(function (tool) {
+                      return {
+                        name: tool.name,
+                        description: tool.description,
+                        inputSchema: tool.inputSchema
+                      };
+                    })
+                  });
+                case 1:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          })));
+          server.setRequestHandler(_types.CallToolRequestSchema, /*#__PURE__*/function () {
+            var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(request) {
+              var _request$params, name, args, result, _formatResult, text, isError;
+              return _regenerator["default"].wrap(function _callee2$(_context2) {
+                while (1) switch (_context2.prev = _context2.next) {
+                  case 0:
+                    _request$params = request.params, name = _request$params.name, args = _request$params.arguments;
+                    _context2.prev = 1;
+                    _context2.next = 4;
+                    return bridge.callTool(name, args !== null && args !== void 0 ? args : {});
+                  case 4:
+                    result = _context2.sent;
+                    _formatResult = (0, _bridgeServer.formatResult)(result), text = _formatResult.text, isError = _formatResult.isError;
+                    return _context2.abrupt("return", _objectSpread({
+                      content: [{
+                        type: 'text',
+                        text: text
+                      }]
+                    }, isError ? {
+                      isError: true
+                    } : {}));
+                  case 9:
+                    _context2.prev = 9;
+                    _context2.t0 = _context2["catch"](1);
+                    return _context2.abrupt("return", {
+                      content: [{
+                        type: 'text',
+                        text: _context2.t0 instanceof Error ? _context2.t0.message : String(_context2.t0)
+                      }],
+                      isError: true
+                    });
+                  case 12:
+                  case "end":
+                    return _context2.stop();
+                }
+              }, _callee2, null, [[1, 9]]);
+            }));
+            return function (_x) {
+              return _ref2.apply(this, arguments);
+            };
+          }());
+          shutdown = /*#__PURE__*/function () {
+            var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+              return _regenerator["default"].wrap(function _callee3$(_context3) {
+                while (1) switch (_context3.prev = _context3.next) {
+                  case 0:
+                    _context3.next = 2;
+                    return bridge.close();
+                  case 2:
+                    process.exit(0);
+                  case 3:
+                  case "end":
+                    return _context3.stop();
+                }
+              }, _callee3);
+            }));
+            return function shutdown() {
+              return _ref3.apply(this, arguments);
+            };
+          }();
+          process.on('SIGINT', shutdown);
+          process.on('SIGTERM', shutdown);
+          _context4.next = 16;
+          return server.connect(new _stdio.StdioServerTransport());
+        case 16:
+          console.error("[kepler-mcp] bridge listening on ws://".concat(started.host, ":").concat(started.port, "/ws"));
+          console.error("[kepler-mcp] open http://".concat(started.host, ":").concat(started.port, "/ in a browser \u2014 it redirects ") + 'to the map page with the token — so the agent can drive the map');
+          console.error("[kepler-mcp] or open ".concat(started.pageUrl));
+        case 19:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _main.apply(this, arguments);
+}
+main()["catch"](function (error) {
+  console.error("[kepler-mcp] ".concat(error instanceof Error ? error.message : String(error)));
+  process.exit(1);
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_interopRequireDefault","require","_regenerator","_defineProperty2","_asyncToGenerator2","_nodeFs","_nodePath","_index","_stdio","_types","_bridgeServer","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","getOwnPropertyDescriptors","defineProperties","defineProperty","DEFAULT_MAP_URL","readVersion","__dirname","directory","depth","manifest","JSON","parse","readFileSync","join","name","version","_unused","dirname","usage","concat","parseArgs","argv","options","i","arg","help","value","Number","isInteger","Error","port","host","mapUrl","main","_main","mark","_callee4","bridge","started","server","shutdown","wrap","_callee4$","_context4","prev","next","process","slice","console","error","abrupt","KeplerMcpBridge","start","sent","Server","capabilities","tools","setRequestHandler","ListToolsRequestSchema","_callee","_callee$","_context","getTools","map","tool","description","inputSchema","stop","CallToolRequestSchema","_ref2","_callee2","request","_request$params","args","result","_formatResult","text","isError","_callee2$","_context2","params","callTool","formatResult","content","type","t0","message","String","_x","_ref3","_callee3","_callee3$","_context3","close","exit","on","connect","StdioServerTransport","pageUrl"],"sources":["../../../src/server/stdio.ts"],"sourcesContent":["#!/usr/bin/env node\n\n// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * `kepler-mcp` — a stdio MCP server for the kepler.gl map surface.\n *\n * The agent starts this process (it speaks MCP on stdin/stdout); the process\n * also listens for the map page on a loopback WebSocket. It prints a URL that\n * carries the one-time token — open that URL and the page connects, after which\n * every map.* tool call executes against the live map.\n *\n * stdout belongs to the MCP protocol: every log line here goes to stderr.\n */\n\nimport {readFileSync} from 'node:fs';\nimport {dirname, join} from 'node:path';\nimport {Server} from '@modelcontextprotocol/sdk/server/index.js';\nimport {StdioServerTransport} from '@modelcontextprotocol/sdk/server/stdio.js';\nimport {CallToolRequestSchema, ListToolsRequestSchema} from '@modelcontextprotocol/sdk/types.js';\nimport {KeplerMcpBridge, formatResult} from './bridge-server';\nimport type {KeplerMcpBridgeOptions} from './bridge-server';\n\nconst DEFAULT_MAP_URL = 'http://localhost:8080';\n\nfunction readVersion(): string {\n  if (typeof __dirname === 'undefined') return '0.0.0';\n  let directory = __dirname;\n  // Walk up until the package manifest is found, so this works both from src/\n  // (babel-node, tests) and from dist/cjs/server (the published bin).\n  for (let depth = 0; depth < 5; depth++) {\n    try {\n      const manifest = JSON.parse(readFileSync(join(directory, 'package.json'), 'utf8'));\n      if (manifest.name === '@kepler.gl/mcp') return manifest.version;\n    } catch {\n      // no manifest at this level — keep walking\n    }\n    directory = dirname(directory);\n  }\n  return '0.0.0';\n}\n\nfunction usage(): string {\n  return [\n    'Usage: kepler-mcp [--port <n>] [--host <h>] [--map-url <url>]',\n    '',\n    'Runs a stdio MCP server for the kepler.gl map surface and waits for a',\n    'kepler.gl page to connect over a loopback WebSocket.',\n    '',\n    '  --port <n>       WebSocket port for the page (default 8765)',\n    '  --host <h>       loopback host to bind (default 127.0.0.1)',\n    `  --map-url <url>  page URL printed with the token (default ${DEFAULT_MAP_URL})`\n  ].join('\\n');\n}\n\nfunction parseArgs(argv: string[]): KeplerMcpBridgeOptions & {help?: boolean} {\n  const options: KeplerMcpBridgeOptions & {help?: boolean} = {};\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n    if (arg === '--help' || arg === '-h') {\n      options.help = true;\n    } else if (arg === '--port') {\n      const value = Number(argv[++i]);\n      if (!Number.isInteger(value) || value < 0 || value > 65535) {\n        throw new Error(`Invalid --port value: ${argv[i]}`);\n      }\n      options.port = value;\n    } else if (arg === '--host') {\n      options.host = argv[++i];\n    } else if (arg === '--map-url') {\n      options.mapUrl = argv[++i];\n    } else {\n      throw new Error(`Unknown argument: ${arg}`);\n    }\n  }\n  return options;\n}\n\nasync function main(): Promise<void> {\n  const options = parseArgs(process.argv.slice(2));\n  if (options.help) {\n    console.error(usage());\n    return;\n  }\n\n  const bridge = new KeplerMcpBridge(options);\n  const started = await bridge.start();\n\n  const server = new Server(\n    {name: 'kepler-mcp', version: readVersion()},\n    {capabilities: {tools: {}}}\n  );\n\n  server.setRequestHandler(ListToolsRequestSchema, async () => ({\n    tools: bridge.getTools().map(tool => ({\n      name: tool.name,\n      description: tool.description,\n      inputSchema: tool.inputSchema as {type: 'object'; [key: string]: unknown}\n    }))\n  }));\n\n  server.setRequestHandler(CallToolRequestSchema, async request => {\n    const {name, arguments: args} = request.params;\n    try {\n      const result = await bridge.callTool(name, (args ?? {}) as Record<string, unknown>);\n      const {text, isError} = formatResult(result);\n      return {content: [{type: 'text' as const, text}], ...(isError ? {isError: true} : {})};\n    } catch (error) {\n      return {\n        content: [\n          {type: 'text' as const, text: error instanceof Error ? error.message : String(error)}\n        ],\n        isError: true\n      };\n    }\n  });\n\n  const shutdown = async () => {\n    await bridge.close();\n    process.exit(0);\n  };\n  process.on('SIGINT', shutdown);\n  process.on('SIGTERM', shutdown);\n\n  await server.connect(new StdioServerTransport());\n\n  console.error(`[kepler-mcp] bridge listening on ws://${started.host}:${started.port}/ws`);\n  console.error(\n    `[kepler-mcp] open http://${started.host}:${started.port}/ in a browser — it redirects ` +\n      'to the map page with the token — so the agent can drive the map'\n  );\n  console.error(`[kepler-mcp] or open ${started.pageUrl}`);\n}\n\nmain().catch(error => {\n  console.error(`[kepler-mcp] ${error instanceof Error ? error.message : String(error)}`);\n  process.exit(1);\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/types.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAP_TOOL_IDS = void 0;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Shared contract types for the kepler.gl map surface.
+ *
+ * This module is the home of the reusable *map surface* contract — the map.*
+ * tool namespace that any AI client can drive. It defines the map.* tool ids
+ * and the `ToolResult` shape so any host (the demo-app browser page, the
+ * kepler-assistant library, or a future MCP server) can implement or consume
+ * the same contract.
+ */
+
+/** A command/tool execution result. */
+
+/**
+ * The v1 map tool surface. These are the command ids the kepler.gl demo-app's
+ * assistant actually registers, reconciled with the kepler-mcp proposal. Most
+ * commands are pure map actuation (set-basemap, add-layer, ...); the table ops
+ * (map.create-table, map.add-column, map.save-data) are DuckDB-backed and are
+ * included because they mutate the map's datasets in place.
+ */
+var MAP_TOOL_IDS = exports.MAP_TOOL_IDS = ['map.set-basemap', 'map.get-boundary', 'map.add-layer', 'map.update-layer-color', 'map.load-data', 'map.save-data', 'map.create-table', 'map.add-column', 'map.add-time-filter', 'map.toggle-time-filter', 'map.split-view', 'map.get-dataset-context'];
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJNQVBfVE9PTF9JRFMiLCJleHBvcnRzIl0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbi8qKlxuICogU2hhcmVkIGNvbnRyYWN0IHR5cGVzIGZvciB0aGUga2VwbGVyLmdsIG1hcCBzdXJmYWNlLlxuICpcbiAqIFRoaXMgbW9kdWxlIGlzIHRoZSBob21lIG9mIHRoZSByZXVzYWJsZSAqbWFwIHN1cmZhY2UqIGNvbnRyYWN0IOKAlCB0aGUgbWFwLipcbiAqIHRvb2wgbmFtZXNwYWNlIHRoYXQgYW55IEFJIGNsaWVudCBjYW4gZHJpdmUuIEl0IGRlZmluZXMgdGhlIG1hcC4qIHRvb2wgaWRzXG4gKiBhbmQgdGhlIGBUb29sUmVzdWx0YCBzaGFwZSBzbyBhbnkgaG9zdCAodGhlIGRlbW8tYXBwIGJyb3dzZXIgcGFnZSwgdGhlXG4gKiBrZXBsZXItYXNzaXN0YW50IGxpYnJhcnksIG9yIGEgZnV0dXJlIE1DUCBzZXJ2ZXIpIGNhbiBpbXBsZW1lbnQgb3IgY29uc3VtZVxuICogdGhlIHNhbWUgY29udHJhY3QuXG4gKi9cblxuLyoqIEEgY29tbWFuZC90b29sIGV4ZWN1dGlvbiByZXN1bHQuICovXG5leHBvcnQgaW50ZXJmYWNlIFRvb2xSZXN1bHQge1xuICBzdWNjZXNzOiBib29sZWFuO1xuICBkYXRhPzogdW5rbm93bjtcbiAgZXJyb3I/OiBzdHJpbmc7XG59XG5cbi8qKlxuICogVGhlIHYxIG1hcCB0b29sIHN1cmZhY2UuIFRoZXNlIGFyZSB0aGUgY29tbWFuZCBpZHMgdGhlIGtlcGxlci5nbCBkZW1vLWFwcCdzXG4gKiBhc3Npc3RhbnQgYWN0dWFsbHkgcmVnaXN0ZXJzLCByZWNvbmNpbGVkIHdpdGggdGhlIGtlcGxlci1tY3AgcHJvcG9zYWwuIE1vc3RcbiAqIGNvbW1hbmRzIGFyZSBwdXJlIG1hcCBhY3R1YXRpb24gKHNldC1iYXNlbWFwLCBhZGQtbGF5ZXIsIC4uLik7IHRoZSB0YWJsZSBvcHNcbiAqIChtYXAuY3JlYXRlLXRhYmxlLCBtYXAuYWRkLWNvbHVtbiwgbWFwLnNhdmUtZGF0YSkgYXJlIER1Y2tEQi1iYWNrZWQgYW5kIGFyZVxuICogaW5jbHVkZWQgYmVjYXVzZSB0aGV5IG11dGF0ZSB0aGUgbWFwJ3MgZGF0YXNldHMgaW4gcGxhY2UuXG4gKi9cbmV4cG9ydCBjb25zdCBNQVBfVE9PTF9JRFMgPSBbXG4gICdtYXAuc2V0LWJhc2VtYXAnLFxuICAnbWFwLmdldC1ib3VuZGFyeScsXG4gICdtYXAuYWRkLWxheWVyJyxcbiAgJ21hcC51cGRhdGUtbGF5ZXItY29sb3InLFxuICAnbWFwLmxvYWQtZGF0YScsXG4gICdtYXAuc2F2ZS1kYXRhJyxcbiAgJ21hcC5jcmVhdGUtdGFibGUnLFxuICAnbWFwLmFkZC1jb2x1bW4nLFxuICAnbWFwLmFkZC10aW1lLWZpbHRlcicsXG4gICdtYXAudG9nZ2xlLXRpbWUtZmlsdGVyJyxcbiAgJ21hcC5zcGxpdC12aWV3JyxcbiAgJ21hcC5nZXQtZGF0YXNldC1jb250ZXh0J1xuXSBhcyBjb25zdDtcblxuZXhwb3J0IHR5cGUgTWFwVG9vbElkID0gKHR5cGVvZiBNQVBfVE9PTF9JRFMpW251bWJlcl07XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7O0FBRUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUVBOztBQU9BO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ08sSUFBTUEsWUFBWSxHQUFBQyxPQUFBLENBQUFELFlBQUEsR0FBRyxDQUMxQixpQkFBaUIsRUFDakIsa0JBQWtCLEVBQ2xCLGVBQWUsRUFDZix3QkFBd0IsRUFDeEIsZUFBZSxFQUNmLGVBQWUsRUFDZixrQkFBa0IsRUFDbEIsZ0JBQWdCLEVBQ2hCLHFCQUFxQixFQUNyQix3QkFBd0IsRUFDeEIsZ0JBQWdCLEVBQ2hCLHlCQUF5QixDQUNqQiIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/commands/add-column-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const addColumnCommandId: "map.add-column";
+export declare function getAddColumnCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/basemap-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const basemapCommandId: "map.set-basemap";
+export declare function getBasemapCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/boundary-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const mapBoundaryCommandId: "map.get-boundary";
+export declare function getMapBoundaryCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/command-wrappers.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Generic utility for converting an existing AI SDK tool into a sqlrooms
+ * `RoomCommand`. Kept dependency-light (only `zod` + `RoomCommand` type) so it
+ * can be reused by any in-browser skill system that wants to expose its
+ * existing AI SDK tools as commands without rewriting them.
+ *
+ * The demo-app's own command factories return `RoomCommand` directly (preferred
+ * when you own the command — see `basemap-command.ts` for the reference shape). This
+ * wrapper is the fallback path for hosts that cannot rewrite their tools:
+ * it folds the tool's `execute`, `inputSchema`, and `toModelOutput` (the
+ * token-trim logic the AI SDK applies between tool call and model) into a
+ * single `RoomCommand.execute` so the registry-stored result already carries
+ * the model-facing subset.
+ */
+import type { RoomCommand } from './types';
+import type { ZodType } from 'zod';
+/** A built AI SDK tool, treated loosely for dynamic dispatch. */
+export type AnyTool = {
+    execute?: (args: any, options: any) => Promise<any>;
+    toModelOutput?: (params: {
+        output: any;
+        toolCallId?: string;
+    }) => any;
+    description?: string;
+    inputSchema?: ZodType;
+};
+/** Metadata that the AI SDK tool does not carry but a `RoomCommand` requires. */
+export type CommandMeta = {
+    /** Stable, namespaced command id, e.g. `map.set-basemap`. */
+    id: string;
+    /** Human-readable name shown in the command palette / listings. */
+    name: string;
+    /** Optional grouping label, e.g. `Map`, `Data`, `GeoDa`. */
+    group?: string;
+    /** Optional search keywords. */
+    keywords?: string[];
+};
+/**
+ * Cast a concrete zod schema (e.g. `z.object({...})`, which is `ZodObject<...>`)
+ * to the `ZodType<unknown>` that `RoomCommand.inputSchema` expects. The
+ * installed zod `ZodObject` is not structurally assignable to sqlrooms'
+ * `ZodType<unknown>` (covariance on the output type), so a cast is required at
+ * the assignment site. This helper centralizes that cast.
+ */
+export declare function asInputSchema(schema: ZodType): ZodType<unknown>;
+/**
+ * Wrap an existing AI SDK tool as a sqlrooms `RoomCommand`. The command's
+ * `execute` calls the tool's `execute` and then applies the tool's
+ * `toModelOutput` (if any) so the trimmed, model-facing shape is what the
+ * registry stores and downstream surfaces (AI skill, palette, CLI, MCP) see.
+ */
+export declare function toolToCommand(tool: AnyTool, meta: CommandMeta): RoomCommand;

package/dist/commands/dataset-context-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const datasetContextCommandId: "map.get-dataset-context";
+export declare function getDatasetContextCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/index.d.ts

@@ -0,0 +1,31 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+/**
+ * Owner string under which all kepler-ai commands are registered in the
+ * room-store command registry. Used by `registerCommandsForOwner` /
+ * `unregisterCommandsForOwner` in the host's store wiring.
+ */
+export declare const KEPLER_COMMAND_OWNER = "kepler-ai";
+/**
+ * Build the kepler-gl map-mutation commands for a given `KeplerContext`.
+ * Returns a map keyed by command id (e.g. `map.set-basemap`) so the registry
+ * registration is a flat merge.
+ */
+export declare function getKeplerCommands(ctx: KeplerContext): Record<string, RoomCommand>;
+export { getBasemapCommand } from './basemap-command';
+export { getViewModeCommand } from './view-mode-command';
+export { getMapBoundaryCommand } from './boundary-command';
+export { getAddLayerCommand, guessDefaultLayer } from './layer-creation-command';
+export { getUpdateLayerColorCommand } from './layer-style-command';
+export { getLoadDataCommand } from './load-data-command';
+export { getSaveDataCommand } from './save-data-command';
+export { getTableCommand } from './table-command';
+export { getAddColumnCommand } from './add-column-command';
+export { getAddTimeFilterCommand } from './time-filter-command';
+export { getToggleTimeFilterCommand } from './toggle-time-filter-command';
+export { getSplitViewCommand } from './split-view-command';
+export { getDatasetContextCommand } from './dataset-context-command';
+export { toolToCommand, asInputSchema } from './command-wrappers';
+export type { AnyTool, CommandMeta } from './command-wrappers';
+export type { KeplerContext, KeplerStateAccessors, VisState, RoomCommandResult, RoomCommandExecuteOutput, ToolDescriptor } from './types';
+export { datasetNameToTableName, convertArrowRowToObject, arrowTableToObjects, tableToLLMResult, formatResultsForLLM, NUMBER_OF_ROWS_RETURN_TO_LLM, LLM_PREVIEW_MAX_TOTAL_LENGTH, LLM_PREVIEW_MAX_VALUE_LENGTH, getValuesFromDataset, getValuesFromVectorTileLayer, isObjectColumn, isVectorTileLayer, stringifyObjectColumn, restoreObjectColumns, buildAddColumnPayload } from './utils';

package/dist/commands/layer-creation-command.d.ts

@@ -0,0 +1,8 @@
+import type { RoomCommand } from './types';
+import type KeplerTable from '@kepler.gl/table';
+import type { KeplerContext } from './types';
+export declare function guessDefaultLayer(dataset: KeplerTable, layerType: string, options?: {
+    countColumn?: string;
+}): any;
+export declare const addLayerCommandId: "map.add-layer";
+export declare function getAddLayerCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/layer-style-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const updateLayerColorCommandId: "map.update-layer-color";
+export declare function getUpdateLayerColorCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/load-data-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const loadDataCommandId: "map.load-data";
+export declare function getLoadDataCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/save-data-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const saveDataCommandId: "map.save-data";
+export declare function getSaveDataCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/split-view-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const splitViewCommandId: "map.split-view";
+export declare function getSplitViewCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/table-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const tableCommandId: "map.create-table";
+export declare function getTableCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/time-filter-command.d.ts

@@ -0,0 +1,13 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export type IntervalKey = '1-second' | '1-minute' | '1-hour' | '1-day' | '1-week' | '1-month' | '3-month' | '1-year';
+export declare const INTERVAL_MILLIS: Record<IntervalKey, number>;
+/**
+ * Infer a sensible animation interval from a time filter's domain and (when
+ * available) the actual distinct timestamps in the dataset. Mirrors the logic
+ * used by spatial-agent's `detectIntervalFromDomain` so the skill-path behaves
+ * identically.
+ */
+export declare function detectIntervalFromDomain(domain: [number, number], mappedValues?: number[]): IntervalKey;
+export declare const addTimeFilterCommandId: "map.add-time-filter";
+export declare function getAddTimeFilterCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/toggle-time-filter-command.d.ts

@@ -0,0 +1,4 @@
+import type { RoomCommand } from './types';
+import type { KeplerContext } from './types';
+export declare const toggleTimeFilterCommandId: "map.toggle-time-filter";
+export declare function getToggleTimeFilterCommand(ctx: KeplerContext): RoomCommand;

package/dist/commands/types.d.ts

@@ -0,0 +1,132 @@
+import type { Table as ArrowTable } from 'apache-arrow';
+import type { ZodType } from 'zod';
+import type { Datasets } from '@kepler.gl/table';
+import type { KeplerDispatch } from './utils';
+/**
+ * Structural subset of `@sqlrooms/room-store`'s `RoomCommand` — enough for the
+ * map.* command factories and for a host to register the built objects. Defined
+ * locally (with `zod`, already a dependency) so this package stays free of
+ * `@sqlrooms/room-store`; the objects the factories build are structurally
+ * compatible with sqlrooms' own `RoomCommand`.
+ */
+export type RoomCommandResult<TData = unknown> = {
+    success: boolean;
+    commandId: string;
+    message?: string;
+    code?: string;
+    data?: TData;
+    error?: string;
+};
+export type RoomCommandExecuteOutput<TData = unknown> = RoomCommandResult<TData> | TData | void;
+export type RoomCommandExecutionContext = {
+    store: unknown;
+    getState: () => unknown;
+    invocation: unknown;
+    signal?: AbortSignal;
+};
+export type RoomCommandPolicyMetadata = {
+    readOnly?: boolean;
+    idempotent?: boolean;
+    riskLevel?: 'low' | 'medium' | 'high';
+    requiresConfirmation?: boolean;
+};
+export type RoomCommand = {
+    id: string;
+    name: string;
+    description?: string;
+    group?: string;
+    keywords?: string[];
+    inputSchema?: ZodType<unknown>;
+    metadata?: RoomCommandPolicyMetadata;
+    execute: (context: RoomCommandExecutionContext, input?: unknown) => RoomCommandExecuteOutput | Promise<RoomCommandExecuteOutput>;
+};
+/**
+ * A command's model-facing descriptor: the id/name/description/group/keywords
+ * plus a JSON-Schema-converted `inputSchema` and the policy metadata. This is
+ * the shape hosts advertise over the wire (e.g. the demo-app bridge's
+ * `toDescriptor`), so it lives in the map surface package to keep the contract
+ * self-contained.
+ */
+export type ToolDescriptor = {
+    id: string;
+    name: string;
+    description?: string;
+    group?: string;
+    keywords?: string[];
+    inputSchema: Record<string, unknown>;
+    metadata?: RoomCommandPolicyMetadata;
+};
+/**
+ * Structural slice of `@sqlrooms/duckdb`'s `DuckDbConnector` — only the methods
+ * the map.* commands call, typed against apache-arrow so the query result flows
+ * into `arrowTableToObjects` / `arrowSchemaToFields` unchanged. Kept local so
+ * this package needs no `@sqlrooms/duckdb` dependency; a host's real sqlrooms
+ * connector satisfies this shape.
+ */
+export type DuckDbConnector = {
+    execute(sql: string, options?: {
+        signal?: AbortSignal;
+    }): PromiseLike<unknown>;
+    query(sql: string, options?: {
+        signal?: AbortSignal;
+    }): PromiseLike<ArrowTable>;
+    loadArrow(table: ArrowTable | Uint8Array, tableName: string, opts?: {
+        schema?: string;
+    }): Promise<void>;
+};
+export type VisState = {
+    datasets: Datasets;
+    layers: any[];
+    layerData: any[];
+    loaders: any[];
+    loadOptions: Record<string, any>;
+    [key: string]: any;
+};
+/**
+ * Accessors to the kepler.gl application state the assistant needs. The host
+ * app supplies these (via `setKeplerStateAccessors`) so this module never
+ * hard-codes a redux state shape (e.g. `demo.keplerGl.map.visState`). Any
+ * app can provide accessors matching its own store.
+ */
+export type KeplerStateAccessors = {
+    getVisState: () => VisState;
+    getMapBoundary: () => {
+        nw: [number, number];
+        se: [number, number];
+    } | undefined;
+};
+/**
+ * KeplerContext provides access to kepler.gl state and dispatch.
+ * This is passed into tool factories instead of using Redux directly.
+ *
+ * The four glue methods (`getValuesFromDataset`, `getDatasetContext`,
+ * `loadTableToKepler`, `loadTableIntoDuckDB`, `getConnector`) are the
+ * kepler-app-bound seam the map.* commands call. They are implemented by the
+ * host's glue (kepler-assistant) so this package stays free of the DuckDB /
+ * kepler-app wiring.
+ */
+export type KeplerContext = {
+    getVisState: () => VisState;
+    getMapBoundary: () => {
+        nw: [number, number];
+        se: [number, number];
+    } | undefined;
+    getMapboxToken: () => string | undefined;
+    dispatch: KeplerDispatch;
+    /** Read a column's values from a kepler dataset (by label or id). */
+    getValuesFromDataset: (datasetName: string, variableName: string) => unknown[];
+    /** Build the dataset+layer context string for the LLM. */
+    getDatasetContext: () => string;
+    /** Load a DuckDB table into kepler.gl as a dataset. */
+    loadTableToKepler: (tableName: string, options?: {
+        autoCreateLayers?: boolean;
+        centerMap?: boolean;
+    }) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Materialize a kepler dataset's columns into a DuckDB table and return the connector. */
+    loadTableIntoDuckDB: (datasetName: string, variableNames: string[], dbTableName: string) => Promise<DuckDbConnector>;
+    /** The shared DuckDB connector (the store's, when wired). */
+    getConnector: () => Promise<DuckDbConnector>;
+};