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

package/dist/cjs/commands/layer-style-command.js

@@ -0,0 +1,136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getUpdateLayerColorCommand = getUpdateLayerColorCommand;
+exports.updateLayerColorCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+var _actions = require("@kepler.gl/actions");
+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; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var updateLayerColorCommandId = exports.updateLayerColorCommandId = 'map.update-layer-color';
+function getUpdateLayerColorCommand(ctx) {
+  return {
+    id: updateLayerColorCommandId,
+    name: 'Update layer color',
+    group: 'Map',
+    description: 'Update the color palette of an existing layer.',
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: _zod.z.object({
+      layerId: _zod.z.string(),
+      numberOfColors: _zod.z.number(),
+      customColors: _zod.z.array(_zod.z.string()).describe('An array of hex color values. Try to generate colors from user description like: van gogh starry night, water color etc.')
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, layerId, numberOfColors, customColors, HEX_COLOR_RE, visState, layers, layer, channel, newConfig, oldColorRange, newColorRange, newVisConfig;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, layerId = _ref.layerId, numberOfColors = _ref.numberOfColors, customColors = _ref.customColors;
+              _context.prev = 1;
+              if (!(typeof layerId !== 'string' || layerId.length === 0)) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error('layerId is required and must be a string.');
+            case 4:
+              if (!(typeof numberOfColors !== 'number' || !Number.isInteger(numberOfColors) || numberOfColors <= 0)) {
+                _context.next = 6;
+                break;
+              }
+              throw new Error('numberOfColors is required and must be a positive integer.');
+            case 6:
+              // The schema/description promise hex colors — a non-hex string would
+              // produce an invalid palette downstream, so reject it up front with an
+              // actionable error instead of a confusing render.
+              HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+              if (!(!Array.isArray(customColors) || customColors.some(function (c) {
+                return typeof c !== 'string' || !HEX_COLOR_RE.test(c);
+              }))) {
+                _context.next = 9;
+                break;
+              }
+              throw new Error('customColors is required and must be an array of hex color strings (e.g. #RRGGBB or #RRGGBBAA).');
+            case 9:
+              visState = ctx.getVisState();
+              layers = visState.layers;
+              layer = layers.find(function (l) {
+                return l.id === layerId;
+              });
+              if (layer) {
+                _context.next = 14;
+                break;
+              }
+              throw new Error("Layer with id ".concat(layerId, " not found"));
+            case 14:
+              if (!(numberOfColors !== customColors.length)) {
+                _context.next = 16;
+                break;
+              }
+              throw new Error("customColors array must contain exactly ".concat(numberOfColors, " colors"));
+            case 16:
+              channel = 'color';
+              newConfig = {};
+              oldColorRange = layer.config.visConfig.colorRange;
+              if (!(oldColorRange.colorMap && customColors.length !== oldColorRange.colorMap.length)) {
+                _context.next = 21;
+                break;
+              }
+              throw new Error("Layer ".concat(layerId, " has ").concat(oldColorRange.colorMap.length, " classes (custom colorMap); provide exactly ").concat(oldColorRange.colorMap.length, " colors, got ").concat(customColors.length, "."));
+            case 21:
+              newColorRange = _objectSpread(_objectSpread({}, oldColorRange), {}, {
+                colors: customColors
+              }, oldColorRange.colorMap ? {
+                colorMap: (0, _toConsumableArray2["default"])(oldColorRange.colorMap.map(function (c, i) {
+                  return [c[0], customColors[i]];
+                }))
+              } : {});
+              newVisConfig = {
+                colorRange: newColorRange,
+                strokeColorRange: newColorRange
+              };
+              ctx.dispatch((0, _actions.layerVisualChannelConfigChange)(layer, newConfig, channel, newVisConfig));
+              return _context.abrupt("return", {
+                success: true,
+                commandId: updateLayerColorCommandId,
+                data: {
+                  details: "Color updated to ".concat(customColors.join(', '), " for layer ").concat(layerId)
+                }
+              });
+            case 27:
+              _context.prev = 27;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: updateLayerColorCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Try to fix the error. If the error persists, ask the user to try with different parameters.'
+                }
+              });
+            case 30:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 27]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_zod","require","_actions","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","updateLayerColorCommandId","exports","getUpdateLayerColorCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","z","object","layerId","string","numberOfColors","number","customColors","array","describe","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","_execCtx","input","_ref","HEX_COLOR_RE","visState","layers","layer","channel","newConfig","oldColorRange","newColorRange","newVisConfig","wrap","_callee$","_context","prev","next","Error","Number","isInteger","Array","isArray","some","c","test","getVisState","find","l","concat","config","visConfig","colorRange","colorMap","colors","_toConsumableArray2","map","i","strokeColorRange","dispatch","layerVisualChannelConfigChange","abrupt","success","commandId","data","details","join","t0","error","message","instruction","stop","_x","_x2"],"sources":["../../../src/commands/layer-style-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {layerVisualChannelConfigChange} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\n\nexport const updateLayerColorCommandId = 'map.update-layer-color' as const;\n\nexport function getUpdateLayerColorCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: updateLayerColorCommandId,\n    name: 'Update layer color',\n    group: 'Map',\n    description: 'Update the color palette of an existing layer.',\n    metadata: {readOnly: false, riskLevel: 'low', idempotent: true},\n    inputSchema: z.object({\n      layerId: z.string(),\n      numberOfColors: z.number(),\n      customColors: z\n        .array(z.string())\n        .describe(\n          'An array of hex color values. Try to generate colors from user description like: van gogh starry night, water color etc.'\n        )\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {layerId, numberOfColors, customColors} = (input ?? {}) as {\n        layerId: string;\n        numberOfColors: number;\n        customColors: string[];\n      };\n      try {\n        // Runtime guards: the bridge/webMCP call execute without zod parsing,\n        // so missing/wrong-typed inputs must fail with actionable errors\n        // instead of a TypeError (e.g. reading `.length` of undefined).\n        if (typeof layerId !== 'string' || layerId.length === 0) {\n          throw new Error('layerId is required and must be a string.');\n        }\n        if (\n          typeof numberOfColors !== 'number' ||\n          !Number.isInteger(numberOfColors) ||\n          numberOfColors <= 0\n        ) {\n          throw new Error('numberOfColors is required and must be a positive integer.');\n        }\n        // The schema/description promise hex colors — a non-hex string would\n        // produce an invalid palette downstream, so reject it up front with an\n        // actionable error instead of a confusing render.\n        const HEX_COLOR_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;\n        if (\n          !Array.isArray(customColors) ||\n          customColors.some(c => typeof c !== 'string' || !HEX_COLOR_RE.test(c))\n        ) {\n          throw new Error(\n            'customColors is required and must be an array of hex color strings (e.g. #RRGGBB or #RRGGBBAA).'\n          );\n        }\n\n        const visState = ctx.getVisState();\n        const layers = visState.layers;\n        const layer = layers.find(l => l.id === layerId);\n        if (!layer) {\n          throw new Error(`Layer with id ${layerId} not found`);\n        }\n\n        if (numberOfColors !== customColors.length) {\n          throw new Error(`customColors array must contain exactly ${numberOfColors} colors`);\n        }\n\n        const channel = 'color';\n        const newConfig = {};\n\n        const oldColorRange = layer.config.visConfig.colorRange;\n        if (oldColorRange.colorMap && customColors.length !== oldColorRange.colorMap.length) {\n          throw new Error(\n            `Layer ${layerId} has ${oldColorRange.colorMap.length} classes (custom colorMap); provide exactly ${oldColorRange.colorMap.length} colors, got ${customColors.length}.`\n          );\n        }\n        const newColorRange = {\n          ...oldColorRange,\n          colors: customColors,\n          ...(oldColorRange.colorMap\n            ? {\n                colorMap: [\n                  ...oldColorRange.colorMap.map((c: any, i: number) => [c[0], customColors[i]])\n                ]\n              }\n            : {})\n        };\n\n        const newVisConfig = {\n          colorRange: newColorRange,\n          strokeColorRange: newColorRange\n        };\n\n        ctx.dispatch(layerVisualChannelConfigChange(layer, newConfig, channel, newVisConfig));\n\n        return {\n          success: true,\n          commandId: updateLayerColorCommandId,\n          data: {details: `Color updated to ${customColors.join(', ')} for layer ${layerId}`}\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: updateLayerColorCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Try to fix the error. If the error persists, ask the user to try with different parameters.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/commands/load-data-command.js

@@ -0,0 +1,270 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLoadDataCommand = getLoadDataCommand;
+exports.loadDataCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+var _actions = require("@kepler.gl/actions");
+var _processors = require("@kepler.gl/processors");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+// MIME type → file extension for data URLs, so a `data:text/csv;base64,...`
+// payload gets a sensible default dataset name (`data.csv`) instead of `data`.
+var DATA_URL_EXTENSIONS = {
+  'text/csv': '.csv',
+  'application/csv': '.csv',
+  'application/json': '.json',
+  'application/geo+json': '.geojson',
+  'application/vnd.apache.arrow.file': '.arrow',
+  'application/vnd.apache.parquet': '.parquet',
+  'text/plain': '.txt'
+};
+function fileNameFromDataUrl(parsedUrl) {
+  var _DATA_URL_EXTENSIONS$;
+  // data:text/csv;base64,... → pathname is "text/csv;base64,"
+  var mime = parsedUrl.pathname.split(';')[0].toLowerCase();
+  return "data".concat((_DATA_URL_EXTENSIONS$ = DATA_URL_EXTENSIONS[mime]) !== null && _DATA_URL_EXTENSIONS$ !== void 0 ? _DATA_URL_EXTENSIONS$ : '');
+}
+
+// Same 32-bit string hash the processors use for dataset ids — applied to a
+// data URL's content so the dataset id is content-derived (unique per payload)
+// without storing the whole (potentially large) data URL in the metadata.
+function hashString(str) {
+  var hash = 0;
+  for (var i = 0; i < str.length; i++) {
+    // eslint-disable-next-line no-bitwise
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    // eslint-disable-next-line no-bitwise
+    hash |= 0;
+  }
+  return hash.toString(36);
+}
+var loadDataCommandId = exports.loadDataCommandId = 'map.load-data';
+function getLoadDataCommand(ctx) {
+  return {
+    id: loadDataCommandId,
+    name: 'Load data from URL',
+    group: 'Map',
+    description: 'Load a dataset from a URL into kepler.gl. The dataset is named after the URL filename, ' + 'or after `datasetName` when provided. Does NOT create a layer — call map.add-layer to visualize. ' + 'Do NOT create a duplicate dataset (e.g. via map.create-table) just to rename it; ' + 'name it here with `datasetName` instead, or use the URL-filename dataset as-is. ' + 'LOCAL FILES: a local file must be served over http(s) — the browser cannot fetch ' + "`file://` paths. To load a file you have on disk: (1) copy it into the demo app's " + 'served directory (e.g. `examples/demo-app/dist/`) and pass `/filename.csv`, or ' + '(2) serve it with a CORS-enabled local server (`npx serve --cors -l 8000` in the ' + "file's folder) and pass `http://localhost:8000/filename.csv`. " + 'EMBEDDED CONTENT: if you have the file content but cannot serve it (e.g. a remote ' + 'browser context), pass it as a data URL — `data:text/csv;base64,<base64 content>` ' + '(encode with `base64 -i file.csv`). Works for small files (up to ~2MB). ' + 'LARGE DATASETS: for files over a few MB, prefer Parquet (.parquet) over GeoJSON/CSV — ' + 'it loads much faster and is less likely to time out. Convert GeoJSON to GeoParquet ' + 'with geopandas (`gdf.to_parquet("data.parquet")`); kepler reads GeoParquet geometry (WKB) natively.',
+    metadata: {
+      readOnly: false,
+      riskLevel: 'medium',
+      requiresConfirmation: true
+    },
+    inputSchema: _zod.z.object({
+      url: _zod.z.string().describe('The URL to load data from. May be a full http(s) URL, a path served by the demo app ' + '(e.g. /data.geojson), or a data URL embedding small file content (data:text/csv;base64,...).'),
+      datasetName: _zod.z.string().optional().describe('Optional name for the loaded dataset. If omitted, the URL filename is used. ' + 'Use this instead of creating a duplicate dataset to rename it.')
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(execCtx, input) {
+        var _ref, url, datasetName, _visState$loaders, _visState$loadOptions, _parsedData$, hasScheme, pageOrigin, parsedUrl, MAX_DATA_URL_LENGTH, visState, response, reason, blob, fileName, file, sourceUrl, batches, result, content, parsedData, _iterator, _step, d, _ref2, dataInfo;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, url = _ref.url, datasetName = _ref.datasetName;
+              _context.prev = 1;
+              if (!(typeof url !== 'string' || url.trim() === '')) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error("Invalid URL: ".concat(url));
+            case 4:
+              // Resolve the URL before validating the scheme. A scheme-less string is
+              // a relative reference — resolve it against the page origin so files
+              // served by the demo app itself (same-origin) can be loaded with a bare
+              // path (e.g. `/sf_streets.geojson`). Browsers cannot fetch `file://`
+              // URLs, so a local file must be served over http(s) by the page's own
+              // server (or a CORS-enabled local server). `data:` URLs are allowed for
+              // small files — they embed the content directly, which is the one way
+              // an agent in a remote browser context can load a local file it cannot
+              // serve. `javascript:` and other schemes are rejected.
+              hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url);
+              pageOrigin = typeof window !== 'undefined' ? window.location.origin : undefined;
+              _context.prev = 6;
+              parsedUrl = hasScheme ? new URL(url) : new URL(url, pageOrigin);
+              _context.next = 13;
+              break;
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](6);
+              throw new Error("Invalid URL: ".concat(url));
+            case 13:
+              if (!(parsedUrl.protocol === 'data:')) {
+                _context.next = 19;
+                break;
+              }
+              // Cap the size so a huge embedded payload can't stall the load or
+              // bloat the tool input. For larger files the agent should serve the
+              // file over http(s) or convert to Parquet instead.
+              MAX_DATA_URL_LENGTH = 2 * 1024 * 1024; // ~2MB of base64
+              if (!(parsedUrl.href.length > MAX_DATA_URL_LENGTH)) {
+                _context.next = 17;
+                break;
+              }
+              throw new Error("Data URL is too large (".concat(parsedUrl.href.length, " chars). ") + 'For files over a few MB, serve the file over http(s) or convert to Parquet.');
+            case 17:
+              _context.next = 21;
+              break;
+            case 19:
+              if (!(parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')) {
+                _context.next = 21;
+                break;
+              }
+              throw new Error("Unsupported URL scheme \"".concat(parsedUrl.protocol, "\". Only http(s) URLs are supported."));
+            case 21:
+              visState = ctx.getVisState(); // Thread the caller's AbortSignal into the fetch so WebMCP/bridge
+              // cancellations stop long-running loads instead of letting them hang.
+              _context.next = 24;
+              return fetch(parsedUrl.href, {
+                signal: execCtx === null || execCtx === void 0 ? void 0 : execCtx.signal
+              });
+            case 24:
+              response = _context.sent;
+              if (response.ok) {
+                _context.next = 28;
+                break;
+              }
+              // Include the numeric status — statusText is often empty (e.g. some
+              // CDNs / error pages), and the code alone makes failures diagnosable.
+              reason = response.statusText ? "HTTP ".concat(response.status, " ").concat(response.statusText) : "HTTP ".concat(response.status);
+              throw new Error("Failed to fetch data from ".concat(parsedUrl.href, ": ").concat(reason));
+            case 28:
+              _context.next = 30;
+              return response.blob();
+            case 30:
+              blob = _context.sent;
+              // Derive the filename from the URL pathname so query strings (e.g.
+              // `data.csv?x=1`) don't end up in the dataset name. A data URL has no
+              // pathname — fall back to a name derived from its MIME type so the
+              // dataset gets a sensible default label (e.g. `data.csv`).
+              fileName = parsedUrl.protocol === 'data:' ? fileNameFromDataUrl(parsedUrl) : parsedUrl.pathname.split('/').pop() || 'data'; // Carry the Blob's MIME type into the File so loader selection in
+              // readFileInBatches can use it — a URL with no extension (or a
+              // misleading one) would otherwise leave file.type empty and fail to
+              // pick the right loader.
+              file = new File([blob], fileName, {
+                type: blob.type || undefined
+              }); // Preserve the source URL so processors hash by URL (avoiding dataset-id
+              // collisions between same-named files) and can attach externally-hosted
+              // metadata — mirrors loadExternallyHostedDataset. Use the RESOLVED href
+              // so a relative path and its absolute form hash to the same dataset id.
+              // For a data URL the href IS the content (potentially large) — hash it
+              // down so the id stays content-derived (unique per payload) without
+              // storing the whole payload in the dataset metadata.
+              sourceUrl = parsedUrl.protocol === 'data:' ? "data:".concat(hashString(parsedUrl.href)) : parsedUrl.href;
+              file.keplerSourceUrl = sourceUrl;
+              _context.next = 37;
+              return (0, _processors.readFileInBatches)({
+                file: file,
+                fileCache: [],
+                loaders: (_visState$loaders = visState.loaders) !== null && _visState$loaders !== void 0 ? _visState$loaders : [],
+                loadOptions: (_visState$loadOptions = visState.loadOptions) !== null && _visState$loadOptions !== void 0 ? _visState$loadOptions : {}
+              });
+            case 37:
+              batches = _context.sent;
+              _context.next = 40;
+              return batches.next();
+            case 40:
+              result = _context.sent;
+              content = {
+                data: [],
+                fileName: ''
+              };
+              parsedData = [];
+            case 43:
+              if (result.done) {
+                _context.next = 55;
+                break;
+              }
+              content = result.value;
+              _context.next = 47;
+              return batches.next();
+            case 47:
+              result = _context.sent;
+              if (!result.done) {
+                _context.next = 53;
+                break;
+              }
+              _context.next = 51;
+              return (0, _processors.processFileData)({
+                content: content,
+                fileCache: []
+              });
+            case 51:
+              parsedData = _context.sent;
+              return _context.abrupt("break", 55);
+            case 53:
+              _context.next = 43;
+              break;
+            case 55:
+              if (!(parsedData.length === 0)) {
+                _context.next = 57;
+                break;
+              }
+              throw new Error("No data could be parsed from ".concat(url, "."));
+            case 57:
+              // Apply a caller-chosen dataset name (default: the URL filename) so the
+              // agent never has to create a duplicate dataset just to rename it.
+              _iterator = _createForOfIteratorHelper(parsedData);
+              try {
+                for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                  d = _step.value;
+                  if (d !== null && d !== void 0 && d.info) {
+                    d.info.label = (_ref2 = datasetName !== null && datasetName !== void 0 ? datasetName : d.info.label) !== null && _ref2 !== void 0 ? _ref2 : fileName;
+                  }
+                }
+              } catch (err) {
+                _iterator.e(err);
+              } finally {
+                _iterator.f();
+              }
+              ctx.dispatch((0, _actions.addDataToMap)({
+                datasets: parsedData,
+                // Do NOT auto-create a layer — the assistant creates the layer
+                // explicitly via `map.add-layer` (with full styling control), so
+                // loading data never produces a duplicate default layer.
+                options: {
+                  autoCreateLayers: false,
+                  centerMap: true
+                }
+              }));
+              dataInfo = (_parsedData$ = parsedData[0]) === null || _parsedData$ === void 0 ? void 0 : _parsedData$.info;
+              return _context.abrupt("return", {
+                success: true,
+                commandId: loadDataCommandId,
+                data: {
+                  details: "Successfully loaded data from ".concat(url),
+                  dataInfo: dataInfo
+                }
+              });
+            case 64:
+              _context.prev = 64;
+              _context.t1 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: loadDataCommandId,
+                error: _context.t1 instanceof Error ? _context.t1.message : 'Unknown error',
+                data: {
+                  instruction: 'Try to fix the error. If the error persists, ask the user to try with a different URL or format.'
+                }
+              });
+            case 67:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 64], [6, 10]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_zod","require","_actions","_processors","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","DATA_URL_EXTENSIONS","fileNameFromDataUrl","parsedUrl","_DATA_URL_EXTENSIONS$","mime","pathname","split","toLowerCase","concat","hashString","str","hash","i","charCodeAt","loadDataCommandId","exports","getLoadDataCommand","ctx","id","group","description","metadata","readOnly","riskLevel","requiresConfirmation","inputSchema","z","object","url","string","describe","datasetName","optional","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","execCtx","input","_ref","_visState$loaders","_visState$loadOptions","_parsedData$","hasScheme","pageOrigin","MAX_DATA_URL_LENGTH","visState","response","reason","blob","fileName","file","sourceUrl","batches","result","content","parsedData","_iterator","_step","d","_ref2","dataInfo","wrap","_callee$","_context","prev","trim","Error","window","location","origin","undefined","URL","t0","protocol","href","getVisState","fetch","signal","sent","ok","statusText","status","pop","File","type","keplerSourceUrl","readFileInBatches","fileCache","loaders","loadOptions","data","processFileData","abrupt","info","label","err","dispatch","addDataToMap","datasets","options","autoCreateLayers","centerMap","success","commandId","details","t1","error","message","instruction","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/load-data-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport {addDataToMap} from '@kepler.gl/actions';\nimport {readFileInBatches, processFileData} from '@kepler.gl/processors';\nimport type {ProcessFileDataContent} from '@kepler.gl/processors';\nimport type {KeplerContext} from './types';\n\n// MIME type → file extension for data URLs, so a `data:text/csv;base64,...`\n// payload gets a sensible default dataset name (`data.csv`) instead of `data`.\nconst DATA_URL_EXTENSIONS: Record<string, string> = {\n  'text/csv': '.csv',\n  'application/csv': '.csv',\n  'application/json': '.json',\n  'application/geo+json': '.geojson',\n  'application/vnd.apache.arrow.file': '.arrow',\n  'application/vnd.apache.parquet': '.parquet',\n  'text/plain': '.txt'\n};\n\nfunction fileNameFromDataUrl(parsedUrl: URL): string {\n  // data:text/csv;base64,... → pathname is \"text/csv;base64,\"\n  const mime = parsedUrl.pathname.split(';')[0].toLowerCase();\n  return `data${DATA_URL_EXTENSIONS[mime] ?? ''}`;\n}\n\n// Same 32-bit string hash the processors use for dataset ids — applied to a\n// data URL's content so the dataset id is content-derived (unique per payload)\n// without storing the whole (potentially large) data URL in the metadata.\nfunction hashString(str: string): string {\n  let hash = 0;\n  for (let i = 0; i < str.length; i++) {\n    // eslint-disable-next-line no-bitwise\n    hash = (hash << 5) - hash + str.charCodeAt(i);\n    // eslint-disable-next-line no-bitwise\n    hash |= 0;\n  }\n  return hash.toString(36);\n}\n\nexport const loadDataCommandId = 'map.load-data' as const;\n\nexport function getLoadDataCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: loadDataCommandId,\n    name: 'Load data from URL',\n    group: 'Map',\n    description:\n      'Load a dataset from a URL into kepler.gl. The dataset is named after the URL filename, ' +\n      'or after `datasetName` when provided. Does NOT create a layer — call map.add-layer to visualize. ' +\n      'Do NOT create a duplicate dataset (e.g. via map.create-table) just to rename it; ' +\n      'name it here with `datasetName` instead, or use the URL-filename dataset as-is. ' +\n      'LOCAL FILES: a local file must be served over http(s) — the browser cannot fetch ' +\n      \"`file://` paths. To load a file you have on disk: (1) copy it into the demo app's \" +\n      'served directory (e.g. `examples/demo-app/dist/`) and pass `/filename.csv`, or ' +\n      '(2) serve it with a CORS-enabled local server (`npx serve --cors -l 8000` in the ' +\n      \"file's folder) and pass `http://localhost:8000/filename.csv`. \" +\n      'EMBEDDED CONTENT: if you have the file content but cannot serve it (e.g. a remote ' +\n      'browser context), pass it as a data URL — `data:text/csv;base64,<base64 content>` ' +\n      '(encode with `base64 -i file.csv`). Works for small files (up to ~2MB). ' +\n      'LARGE DATASETS: for files over a few MB, prefer Parquet (.parquet) over GeoJSON/CSV — ' +\n      'it loads much faster and is less likely to time out. Convert GeoJSON to GeoParquet ' +\n      'with geopandas (`gdf.to_parquet(\"data.parquet\")`); kepler reads GeoParquet geometry (WKB) natively.',\n    metadata: {readOnly: false, riskLevel: 'medium', requiresConfirmation: true},\n    inputSchema: z.object({\n      url: z\n        .string()\n        .describe(\n          'The URL to load data from. May be a full http(s) URL, a path served by the demo app ' +\n            '(e.g. /data.geojson), or a data URL embedding small file content (data:text/csv;base64,...).'\n        ),\n      datasetName: z\n        .string()\n        .optional()\n        .describe(\n          'Optional name for the loaded dataset. If omitted, the URL filename is used. ' +\n            'Use this instead of creating a duplicate dataset to rename it.'\n        )\n    }) as any,\n    execute: async (execCtx, input) => {\n      const {url, datasetName} = (input ?? {}) as {url: string; datasetName?: string};\n      try {\n        if (typeof url !== 'string' || url.trim() === '') {\n          throw new Error(`Invalid URL: ${url}`);\n        }\n\n        // Resolve the URL before validating the scheme. A scheme-less string is\n        // a relative reference — resolve it against the page origin so files\n        // served by the demo app itself (same-origin) can be loaded with a bare\n        // path (e.g. `/sf_streets.geojson`). Browsers cannot fetch `file://`\n        // URLs, so a local file must be served over http(s) by the page's own\n        // server (or a CORS-enabled local server). `data:` URLs are allowed for\n        // small files — they embed the content directly, which is the one way\n        // an agent in a remote browser context can load a local file it cannot\n        // serve. `javascript:` and other schemes are rejected.\n        const hasScheme = /^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(url);\n        const pageOrigin = typeof window !== 'undefined' ? window.location.origin : undefined;\n        let parsedUrl: URL;\n        try {\n          parsedUrl = hasScheme ? new URL(url) : new URL(url, pageOrigin);\n        } catch {\n          throw new Error(`Invalid URL: ${url}`);\n        }\n        if (parsedUrl.protocol === 'data:') {\n          // Cap the size so a huge embedded payload can't stall the load or\n          // bloat the tool input. For larger files the agent should serve the\n          // file over http(s) or convert to Parquet instead.\n          const MAX_DATA_URL_LENGTH = 2 * 1024 * 1024; // ~2MB of base64\n          if (parsedUrl.href.length > MAX_DATA_URL_LENGTH) {\n            throw new Error(\n              `Data URL is too large (${parsedUrl.href.length} chars). ` +\n                'For files over a few MB, serve the file over http(s) or convert to Parquet.'\n            );\n          }\n        } else if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {\n          throw new Error(\n            `Unsupported URL scheme \"${parsedUrl.protocol}\". Only http(s) URLs are supported.`\n          );\n        }\n\n        const visState = ctx.getVisState();\n        // Thread the caller's AbortSignal into the fetch so WebMCP/bridge\n        // cancellations stop long-running loads instead of letting them hang.\n        const response = await fetch(parsedUrl.href, {signal: execCtx?.signal});\n        if (!response.ok) {\n          // Include the numeric status — statusText is often empty (e.g. some\n          // CDNs / error pages), and the code alone makes failures diagnosable.\n          const reason = response.statusText\n            ? `HTTP ${response.status} ${response.statusText}`\n            : `HTTP ${response.status}`;\n          throw new Error(`Failed to fetch data from ${parsedUrl.href}: ${reason}`);\n        }\n\n        const blob = await response.blob();\n        // Derive the filename from the URL pathname so query strings (e.g.\n        // `data.csv?x=1`) don't end up in the dataset name. A data URL has no\n        // pathname — fall back to a name derived from its MIME type so the\n        // dataset gets a sensible default label (e.g. `data.csv`).\n        const fileName =\n          parsedUrl.protocol === 'data:'\n            ? fileNameFromDataUrl(parsedUrl)\n            : parsedUrl.pathname.split('/').pop() || 'data';\n        // Carry the Blob's MIME type into the File so loader selection in\n        // readFileInBatches can use it — a URL with no extension (or a\n        // misleading one) would otherwise leave file.type empty and fail to\n        // pick the right loader.\n        const file = new File([blob], fileName, {type: blob.type || undefined});\n        // Preserve the source URL so processors hash by URL (avoiding dataset-id\n        // collisions between same-named files) and can attach externally-hosted\n        // metadata — mirrors loadExternallyHostedDataset. Use the RESOLVED href\n        // so a relative path and its absolute form hash to the same dataset id.\n        // For a data URL the href IS the content (potentially large) — hash it\n        // down so the id stays content-derived (unique per payload) without\n        // storing the whole payload in the dataset metadata.\n        const sourceUrl =\n          parsedUrl.protocol === 'data:' ? `data:${hashString(parsedUrl.href)}` : parsedUrl.href;\n        (file as File & {keplerSourceUrl?: string}).keplerSourceUrl = sourceUrl;\n\n        const batches = await readFileInBatches({\n          file,\n          fileCache: [],\n          loaders: visState.loaders ?? [],\n          loadOptions: visState.loadOptions ?? {}\n        });\n\n        let result = await batches.next();\n        let content: ProcessFileDataContent = {data: [], fileName: ''};\n        let parsedData: any[] = [];\n\n        while (!result.done) {\n          content = result.value as ProcessFileDataContent;\n          result = await batches.next();\n          if (result.done) {\n            parsedData = await processFileData({content, fileCache: []});\n            break;\n          }\n        }\n\n        if (parsedData.length === 0) {\n          throw new Error(`No data could be parsed from ${url}.`);\n        }\n\n        // Apply a caller-chosen dataset name (default: the URL filename) so the\n        // agent never has to create a duplicate dataset just to rename it.\n        for (const d of parsedData) {\n          if (d?.info) {\n            d.info.label = datasetName ?? d.info.label ?? fileName;\n          }\n        }\n\n        ctx.dispatch(\n          addDataToMap({\n            datasets: parsedData,\n            // Do NOT auto-create a layer — the assistant creates the layer\n            // explicitly via `map.add-layer` (with full styling control), so\n            // loading data never produces a duplicate default layer.\n            options: {autoCreateLayers: false, centerMap: true}\n          })\n        );\n\n        const dataInfo = parsedData[0]?.info;\n        return {\n          success: true,\n          commandId: loadDataCommandId,\n          data: {details: `Successfully loaded data from ${url}`, dataInfo}\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: loadDataCommandId,\n          error: error instanceof Error ? error.message : 'Unknown error',\n          data: {\n            instruction:\n              'Try to fix the error. If the error persists, ask the user to try with a different URL or format.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/commands/save-data-command.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSaveDataCommand = getSaveDataCommand;
+exports.saveDataCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var saveDataCommandId = exports.saveDataCommandId = 'map.save-data';
+function getSaveDataCommand(ctx) {
+  return {
+    id: saveDataCommandId,
+    name: 'Save DuckDB table to map',
+    group: 'Map',
+    description: 'Save a DuckDB table to kepler.gl as a map dataset. Works with any table including those from buffer, zipcode, county, state, isochrone, routing, query results, etc.',
+    metadata: {
+      readOnly: false,
+      riskLevel: 'medium',
+      requiresConfirmation: true
+    },
+    inputSchema: _zod.z.object({
+      datasetNames: _zod.z.array(_zod.z.string()).min(1).describe('The names of the DuckDB tables to load into kepler.gl.')
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, datasetNames, loadedDatasetNames, _iterator, _step, datasetName, result;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, datasetNames = _ref.datasetNames;
+              _context.prev = 1;
+              if (!(!Array.isArray(datasetNames) || datasetNames.length === 0 || datasetNames.some(function (name) {
+                return typeof name !== 'string' || name.length === 0;
+              }))) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error('datasetNames must be a non-empty array of DuckDB table names, e.g. ["my_table"].');
+            case 4:
+              loadedDatasetNames = [];
+              _iterator = _createForOfIteratorHelper(datasetNames);
+              _context.prev = 6;
+              _iterator.s();
+            case 8:
+              if ((_step = _iterator.n()).done) {
+                _context.next = 18;
+                break;
+              }
+              datasetName = _step.value;
+              _context.next = 12;
+              return ctx.loadTableToKepler(datasetName);
+            case 12:
+              result = _context.sent;
+              if (result.success) {
+                _context.next = 15;
+                break;
+              }
+              throw new Error("Cannot save table \"".concat(datasetName, "\" to kepler.gl: ").concat(result.error));
+            case 15:
+              loadedDatasetNames.push(datasetName);
+            case 16:
+              _context.next = 8;
+              break;
+            case 18:
+              _context.next = 23;
+              break;
+            case 20:
+              _context.prev = 20;
+              _context.t0 = _context["catch"](6);
+              _iterator.e(_context.t0);
+            case 23:
+              _context.prev = 23;
+              _iterator.f();
+              return _context.finish(23);
+            case 26:
+              if (!(loadedDatasetNames.length === 0)) {
+                _context.next = 28;
+                break;
+              }
+              throw new Error("No datasets found from ".concat(datasetNames.join(', ')));
+            case 28:
+              return _context.abrupt("return", {
+                success: true,
+                commandId: saveDataCommandId,
+                data: {
+                  savedDatasetNames: loadedDatasetNames,
+                  details: "Successfully saved dataset(s): ".concat(loadedDatasetNames.join(', '), " in kepler.gl")
+                }
+              });
+            case 31:
+              _context.prev = 31;
+              _context.t1 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: saveDataCommandId,
+                error: "Cannot save data to kepler.gl: ".concat(_context.t1 instanceof Error ? _context.t1.message : String(_context.t1))
+              });
+            case 34:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 31], [6, 20, 23, 26]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_zod","require","_createForOfIteratorHelper","r","e","t","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","_n","F","s","n","done","value","f","TypeError","o","a","u","call","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","saveDataCommandId","exports","getSaveDataCommand","ctx","id","group","description","metadata","readOnly","riskLevel","requiresConfirmation","inputSchema","z","object","datasetNames","array","string","min","describe","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","_execCtx","input","_ref","loadedDatasetNames","_iterator","_step","datasetName","result","wrap","_callee$","_context","prev","some","Error","loadTableToKepler","sent","success","concat","error","push","t0","finish","join","abrupt","commandId","data","savedDatasetNames","details","t1","message","String","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/save-data-command.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport type {RoomCommand} from './types';\nimport {z} from 'zod';\nimport type {KeplerContext} from './types';\n\nexport const saveDataCommandId = 'map.save-data' as const;\n\nexport function getSaveDataCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: saveDataCommandId,\n    name: 'Save DuckDB table to map',\n    group: 'Map',\n    description:\n      'Save a DuckDB table to kepler.gl as a map dataset. Works with any table including those from buffer, zipcode, county, state, isochrone, routing, query results, etc.',\n    metadata: {readOnly: false, riskLevel: 'medium', requiresConfirmation: true},\n    inputSchema: z.object({\n      datasetNames: z\n        .array(z.string())\n        .min(1)\n        .describe('The names of the DuckDB tables to load into kepler.gl.')\n    }) as any,\n    execute: async (_execCtx, input) => {\n      const {datasetNames} = (input ?? {}) as {datasetNames: string[]};\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing,\n        // so a missing/empty/wrong-typed datasetNames must not fall through to\n        // a confusing TypeError or an unhelpful \"No datasets found…\" message.\n        if (\n          !Array.isArray(datasetNames) ||\n          datasetNames.length === 0 ||\n          datasetNames.some(name => typeof name !== 'string' || name.length === 0)\n        ) {\n          throw new Error(\n            'datasetNames must be a non-empty array of DuckDB table names, e.g. [\"my_table\"].'\n          );\n        }\n\n        const loadedDatasetNames: string[] = [];\n\n        for (const datasetName of datasetNames) {\n          const result = await ctx.loadTableToKepler(datasetName);\n          if (!result.success) {\n            throw new Error(`Cannot save table \"${datasetName}\" to kepler.gl: ${result.error}`);\n          }\n          loadedDatasetNames.push(datasetName);\n        }\n\n        if (loadedDatasetNames.length === 0) {\n          throw new Error(`No datasets found from ${datasetNames.join(', ')}`);\n        }\n\n        return {\n          success: true,\n          commandId: saveDataCommandId,\n          data: {\n            savedDatasetNames: loadedDatasetNames,\n            details: `Successfully saved dataset(s): ${loadedDatasetNames.join(', ')} in kepler.gl`\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: saveDataCommandId,\n          error: `Cannot save data to kepler.gl: ${\n            error instanceof Error ? error.message : String(error)\n          }`\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}