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

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

@@ -0,0 +1,130 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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) { _defineProperty(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
+
+import { z } from 'zod';
+import { layerVisualChannelConfigChange } from '@kepler.gl/actions';
+export var updateLayerColorCommandId = 'map.update-layer-color';
+export 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: z.object({
+      layerId: z.string(),
+      numberOfColors: z.number(),
+      customColors: z.array(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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, layerId, numberOfColors, customColors, HEX_COLOR_RE, visState, layers, layer, channel, newConfig, oldColorRange, newColorRange, newVisConfig;
+        return _regeneratorRuntime.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: _toConsumableArray(oldColorRange.colorMap.map(function (c, i) {
+                  return [c[0], customColors[i]];
+                }))
+              } : {});
+              newVisConfig = {
+                colorRange: newColorRange,
+                strokeColorRange: newColorRange
+              };
+              ctx.dispatch(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":["z","layerVisualChannelConfigChange","updateLayerColorCommandId","getUpdateLayerColorCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","layerId","string","numberOfColors","number","customColors","array","describe","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","HEX_COLOR_RE","visState","layers","layer","channel","newConfig","oldColorRange","newColorRange","newVisConfig","wrap","_callee$","_context","prev","next","length","Error","Number","isInteger","Array","isArray","some","c","test","getVisState","find","l","concat","config","visConfig","colorRange","colorMap","_objectSpread","colors","_toConsumableArray","map","i","strokeColorRange","dispatch","abrupt","success","commandId","data","details","join","t0","error","message","instruction","stop","_x","_x2","apply","arguments"],"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/esm/commands/load-data-command.js

@@ -0,0 +1,264 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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
+
+import { z } from 'zod';
+import { addDataToMap } from '@kepler.gl/actions';
+import { readFileInBatches, processFileData } from '@kepler.gl/processors';
+// 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);
+}
+export var loadDataCommandId = 'map.load-data';
+export 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: z.object({
+      url: 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: 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 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.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 _regeneratorRuntime.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 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 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(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":["z","addDataToMap","readFileInBatches","processFileData","DATA_URL_EXTENSIONS","fileNameFromDataUrl","parsedUrl","_DATA_URL_EXTENSIONS$","mime","pathname","split","toLowerCase","concat","hashString","str","hash","i","length","charCodeAt","toString","loadDataCommandId","getLoadDataCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","requiresConfirmation","inputSchema","object","url","string","describe","datasetName","optional","execute","_execute","_asyncToGenerator","_regeneratorRuntime","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","next","trim","Error","test","window","location","origin","undefined","URL","t0","protocol","href","getVisState","fetch","signal","sent","ok","statusText","status","pop","File","type","keplerSourceUrl","fileCache","loaders","loadOptions","data","done","value","abrupt","_createForOfIteratorHelper","s","n","info","label","err","e","f","dispatch","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/esm/commands/save-data-command.js

@@ -0,0 +1,112 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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
+
+import { z } from 'zod';
+export var saveDataCommandId = 'map.save-data';
+export 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: z.object({
+      datasetNames: z.array(z.string()).min(1).describe('The names of the DuckDB tables to load into kepler.gl.')
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, datasetNames, loadedDatasetNames, _iterator, _step, datasetName, result;
+        return _regeneratorRuntime.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":["z","saveDataCommandId","getSaveDataCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","requiresConfirmation","inputSchema","object","datasetNames","array","string","min","describe","execute","_execute","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_execCtx","input","_ref","loadedDatasetNames","_iterator","_step","datasetName","result","wrap","_callee$","_context","prev","next","Array","isArray","length","some","Error","_createForOfIteratorHelper","s","n","done","value","loadTableToKepler","sent","success","concat","error","push","t0","e","f","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":[]}