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

package/dist/cjs/commands/add-column-command.js

@@ -0,0 +1,192 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addColumnCommandId = void 0;
+exports.getAddColumnCommand = getAddColumnCommand;
+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 _utils = require("./utils");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var addColumnCommandId = exports.addColumnCommandId = 'map.add-column';
+function getAddColumnCommand(ctx) {
+  return {
+    id: addColumnCommandId,
+    name: 'Add a column to an existing map dataset',
+    group: 'Map',
+    description: "Add a NEW column to an existing kepler.gl dataset (table), in place. The dataset keeps its name, id, color and layers; existing columns are untouched, so layers, filters and tooltips keep working unchanged.\nThe new column's values come from exactly ONE of two sources:\n- copyFromColumn \u2014 copy the values of an existing column. This is how you \"rename\" a column in place: to rename \"fare\" to \"fare_amount\", add a new column \"fare_amount\" that copies \"fare\" (the original \"fare\" column stays \u2014 this command never removes columns).\n- expression \u2014 an SQL expression computed in DuckDB against the dataset's rows, e.g. a z-score: \"(HR60 - AVG(HR60) OVER()) / STDDEV(HR60) OVER()\" adds HR60_Z holding the standardized value of HR60. The expression may reference existing columns and window functions; it must produce exactly one value per row.\nCHANGING A COLUMN'S TYPE: use expression to add a NEW column that casts the original, e.g. to turn \"NOSOUTH\" (numeric) into a string, add a new column with expression \"NOSOUTH::VARCHAR\" (or \"CAST(NOSOUTH AS VARCHAR)\"). The values become strings; the original column stays. Name the new column clearly (e.g. \"NOSOUTH_str\") or as the user requests.\nIMPORTANT: this command only ADDS columns. It cannot delete or rename-in-place an existing column, and it never changes the type OF an existing column in place \u2014 a type change is achieved by adding a NEW column holding the cast values. If you need to remove columns or rebuild the whole table, use map.create-table (which creates a NEW dataset; the original is untouched).",
+    metadata: {
+      readOnly: false,
+      riskLevel: 'medium',
+      idempotent: false
+    },
+    inputSchema: _zod.z.object({
+      datasetName: _zod.z.string().min(1).describe('The name (label) or id of the dataset to add the column to'),
+      newColumnName: _zod.z.string().min(1).describe('The name of the new column to add. Must not already exist in the dataset.'),
+      copyFromColumn: _zod.z.string().min(1).optional().describe('The name of an EXISTING column whose values the new column will copy. Mutually exclusive with `expression` — provide exactly one.'),
+      expression: _zod.z.string().min(1).optional().describe('An SQL expression computed in DuckDB against the dataset rows; the result becomes the new column. e.g. z-score: "(HR60 - AVG(HR60) OVER()) / STDDEV(HR60) OVER()". Mutually exclusive with `copyFromColumn` — provide exactly one.')
+    }).superRefine(function (data, ctx) {
+      var provided = [data.copyFromColumn, data.expression].filter(function (v) {
+        return v != null;
+      }).length;
+      if (provided !== 1) {
+        ctx.addIssue({
+          code: _zod.z.ZodIssueCode.custom,
+          message: 'Provide exactly one of copyFromColumn or expression.'
+        });
+      }
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, datasetName, newColumnName, copyFromColumn, expression, provided, visState, datasets, dataId, fieldNames, dbTableName, db, escapeIdent, appendedSql, arrowResult, _buildAddColumnPayloa, rows, fields, previewRows, valueSource;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, datasetName = _ref.datasetName, newColumnName = _ref.newColumnName, copyFromColumn = _ref.copyFromColumn, expression = _ref.expression;
+              _context.prev = 1;
+              // Runtime guard: the bridge/webMCP call execute without zod parsing, so
+              // the superRefine "exactly one of copyFromColumn/expression" constraint
+              // is not enforced. Without it, both-missing would build
+              // `(undefined) AS ...` and produce a confusing DuckDB error.
+              provided = [copyFromColumn, expression].filter(function (v) {
+                return v != null;
+              }).length;
+              if (!(provided !== 1)) {
+                _context.next = 5;
+                break;
+              }
+              throw new Error('Provide exactly one of copyFromColumn or expression.');
+            case 5:
+              if (!(typeof datasetName !== 'string' || datasetName.length === 0)) {
+                _context.next = 7;
+                break;
+              }
+              throw new Error('datasetName must be a non-empty string.');
+            case 7:
+              if (!(typeof newColumnName !== 'string' || newColumnName.length === 0)) {
+                _context.next = 9;
+                break;
+              }
+              throw new Error('newColumnName must be a non-empty string.');
+            case 9:
+              if (!(copyFromColumn != null && (typeof copyFromColumn !== 'string' || copyFromColumn.length === 0))) {
+                _context.next = 11;
+                break;
+              }
+              throw new Error('copyFromColumn must be a non-empty string.');
+            case 11:
+              if (!(expression != null && (typeof expression !== 'string' || expression.length === 0))) {
+                _context.next = 13;
+                break;
+              }
+              throw new Error('expression must be a non-empty string.');
+            case 13:
+              visState = ctx.getVisState();
+              datasets = visState.datasets;
+              dataId = Object.keys(datasets).find(function (id) {
+                return id === datasetName || datasets[id].label === datasetName;
+              });
+              if (dataId) {
+                _context.next = 18;
+                break;
+              }
+              throw new Error("Dataset \"".concat(datasetName, "\" not found."));
+            case 18:
+              fieldNames = datasets[dataId].fields.map(function (f) {
+                return f.name;
+              });
+              if (!(copyFromColumn != null && !fieldNames.includes(copyFromColumn))) {
+                _context.next = 21;
+                break;
+              }
+              throw new Error("Column \"".concat(copyFromColumn, "\" does not exist in dataset \"").concat(datasetName, "\". ") + "Existing columns: ".concat(fieldNames.join(', '), "."));
+            case 21:
+              if (!fieldNames.includes(newColumnName)) {
+                _context.next = 23;
+                break;
+              }
+              throw new Error("Column \"".concat(newColumnName, "\" already exists in dataset \"").concat(datasetName, "\". Choose a different name."));
+            case 23:
+              // Derive the DuckDB table name from the resolved dataset id, not the
+              // user-provided label: different labels can sanitize to the same table
+              // name (e.g. "A-B" vs "A B"), which would clobber another dataset's
+              // temp table inside DuckDB and run the SQL against unintended data.
+              dbTableName = (0, _utils.datasetNameToTableName)(dataId); // Pass the user-provided datasetName (label or id) to
+              // loadTableIntoDuckDB — the documented KeplerContext contract — not
+              // the resolved id.
+              _context.next = 26;
+              return ctx.loadTableIntoDuckDB(datasetName, fieldNames, dbTableName);
+            case 26:
+              db = _context.sent;
+              // Add-only: compute ONLY the new column in DuckDB. Existing columns are
+              // never round-tripped through DuckDB/Arrow — `tableFromArrays` infers a
+              // single Arrow type for `_geojson`, and a dataset mixing Polygon and
+              // MultiPolygon features gets the shallower type, so the MultiPolygon
+              // coordinates come back as nulls and the geometry disappears.
+              // `buildAddColumnPayload` rebuilds the payload from the original kepler
+              // values instead, appending the new column from this single-column result.
+              // Escape double quotes in identifier names before embedding them in
+              // quoted SQL identifiers — a `"` in copyFromColumn/newColumnName would
+              // otherwise break the query or enable SQL injection into DuckDB. (The
+              // `expression` is user-provided SQL by design, so it is not escaped.)
+              escapeIdent = function escapeIdent(name) {
+                return name.replace(/"/g, '""');
+              };
+              appendedSql = copyFromColumn != null ? "\"".concat(escapeIdent(copyFromColumn), "\" AS \"").concat(escapeIdent(newColumnName), "\"") : "(".concat(expression, ") AS \"").concat(escapeIdent(newColumnName), "\"");
+              _context.next = 31;
+              return db.query("SELECT ".concat(appendedSql, " FROM \"").concat(dbTableName, "\""));
+            case 31:
+              arrowResult = _context.sent;
+              _buildAddColumnPayloa = (0, _utils.buildAddColumnPayload)(datasets, visState.layers, datasetName, newColumnName, arrowResult), rows = _buildAddColumnPayloa.rows, fields = _buildAddColumnPayloa.fields;
+              ctx.dispatch((0, _actions.updateDataset)(dataId, {
+                rows: rows,
+                fields: fields
+              }));
+
+              // LLM-facing preview: first 5 rows of the full (original + new) payload.
+              previewRows = rows.slice(0, 5).map(function (r) {
+                return Object.fromEntries(fields.map(function (f, i) {
+                  return [f.name, r[i]];
+                }));
+              });
+              valueSource = copyFromColumn != null ? "copied from \"".concat(copyFromColumn, "\"") : "computed";
+              return _context.abrupt("return", {
+                success: true,
+                commandId: addColumnCommandId,
+                data: {
+                  details: "Added column \"".concat(newColumnName, "\" to dataset \"").concat(datasetName, "\" (").concat(valueSource, ", ").concat(rows.length, " rows)."),
+                  addedColumns: [newColumnName],
+                  firstFiveRows: (0, _utils.tableToLLMResult)(previewRows)
+                }
+              });
+            case 39:
+              _context.prev = 39;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: addColumnCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0),
+                data: {
+                  instruction: 'Please explain the error and give a plan to fix it. Then try again.'
+                }
+              });
+            case 42:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 39]]);
+      }));
+      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","_utils","addColumnCommandId","exports","getAddColumnCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","z","object","datasetName","string","min","describe","newColumnName","copyFromColumn","optional","expression","superRefine","data","provided","filter","v","length","addIssue","code","ZodIssueCode","custom","message","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","_execCtx","input","_ref","visState","datasets","dataId","fieldNames","dbTableName","db","escapeIdent","appendedSql","arrowResult","_buildAddColumnPayloa","rows","fields","previewRows","valueSource","wrap","_callee$","_context","prev","next","Error","getVisState","Object","keys","find","label","concat","map","f","includes","join","datasetNameToTableName","loadTableIntoDuckDB","sent","replace","query","buildAddColumnPayload","layers","dispatch","updateDataset","slice","r","fromEntries","i","abrupt","success","commandId","details","addedColumns","firstFiveRows","tableToLLMResult","t0","error","String","instruction","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/add-column-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 {updateDataset} from '@kepler.gl/actions';\nimport type {KeplerContext} from './types';\nimport {buildAddColumnPayload} from './utils';\nimport {datasetNameToTableName, tableToLLMResult} from './utils';\n\nexport const addColumnCommandId = 'map.add-column' as const;\n\nexport function getAddColumnCommand(ctx: KeplerContext): RoomCommand {\n  return {\n    id: addColumnCommandId,\n    name: 'Add a column to an existing map dataset',\n    group: 'Map',\n    description: `Add a NEW column to an existing kepler.gl dataset (table), in place. The dataset keeps its name, id, color and layers; existing columns are untouched, so layers, filters and tooltips keep working unchanged.\nThe new column's values come from exactly ONE of two sources:\n- copyFromColumn — copy the values of an existing column. This is how you \"rename\" a column in place: to rename \"fare\" to \"fare_amount\", add a new column \"fare_amount\" that copies \"fare\" (the original \"fare\" column stays — this command never removes columns).\n- expression — an SQL expression computed in DuckDB against the dataset's rows, e.g. a z-score: \"(HR60 - AVG(HR60) OVER()) / STDDEV(HR60) OVER()\" adds HR60_Z holding the standardized value of HR60. The expression may reference existing columns and window functions; it must produce exactly one value per row.\nCHANGING A COLUMN'S TYPE: use expression to add a NEW column that casts the original, e.g. to turn \"NOSOUTH\" (numeric) into a string, add a new column with expression \"NOSOUTH::VARCHAR\" (or \"CAST(NOSOUTH AS VARCHAR)\"). The values become strings; the original column stays. Name the new column clearly (e.g. \"NOSOUTH_str\") or as the user requests.\nIMPORTANT: this command only ADDS columns. It cannot delete or rename-in-place an existing column, and it never changes the type OF an existing column in place — a type change is achieved by adding a NEW column holding the cast values. If you need to remove columns or rebuild the whole table, use map.create-table (which creates a NEW dataset; the original is untouched).`,\n    metadata: {readOnly: false, riskLevel: 'medium', idempotent: false},\n    inputSchema: z\n      .object({\n        datasetName: z\n          .string()\n          .min(1)\n          .describe('The name (label) or id of the dataset to add the column to'),\n        newColumnName: z\n          .string()\n          .min(1)\n          .describe('The name of the new column to add. Must not already exist in the dataset.'),\n        copyFromColumn: z\n          .string()\n          .min(1)\n          .optional()\n          .describe(\n            'The name of an EXISTING column whose values the new column will copy. Mutually exclusive with `expression` — provide exactly one.'\n          ),\n        expression: z\n          .string()\n          .min(1)\n          .optional()\n          .describe(\n            'An SQL expression computed in DuckDB against the dataset rows; the result becomes the new column. e.g. z-score: \"(HR60 - AVG(HR60) OVER()) / STDDEV(HR60) OVER()\". Mutually exclusive with `copyFromColumn` — provide exactly one.'\n          )\n      })\n      .superRefine((data, ctx) => {\n        const provided = [data.copyFromColumn, data.expression].filter(v => v != null).length;\n        if (provided !== 1) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: 'Provide exactly one of copyFromColumn or expression.'\n          });\n        }\n      }) as any,\n    execute: async (_execCtx, input) => {\n      const {datasetName, newColumnName, copyFromColumn, expression} = (input ?? {}) as {\n        datasetName: string;\n        newColumnName: string;\n        copyFromColumn?: string;\n        expression?: string;\n      };\n      try {\n        // Runtime guard: the bridge/webMCP call execute without zod parsing, so\n        // the superRefine \"exactly one of copyFromColumn/expression\" constraint\n        // is not enforced. Without it, both-missing would build\n        // `(undefined) AS ...` and produce a confusing DuckDB error.\n        const provided = [copyFromColumn, expression].filter(v => v != null).length;\n        if (provided !== 1) {\n          throw new Error('Provide exactly one of copyFromColumn or expression.');\n        }\n        if (typeof datasetName !== 'string' || datasetName.length === 0) {\n          throw new Error('datasetName must be a non-empty string.');\n        }\n        if (typeof newColumnName !== 'string' || newColumnName.length === 0) {\n          throw new Error('newColumnName must be a non-empty string.');\n        }\n        // The bridge/webMCP path skips zod, so an empty copyFromColumn/expression\n        // would slip through and build `() AS ...` / `\"\" AS ...` — a confusing\n        // DuckDB error instead of an actionable one. Enforce non-empty strings\n        // for whichever source is selected.\n        if (\n          copyFromColumn != null &&\n          (typeof copyFromColumn !== 'string' || copyFromColumn.length === 0)\n        ) {\n          throw new Error('copyFromColumn must be a non-empty string.');\n        }\n        if (expression != null && (typeof expression !== 'string' || expression.length === 0)) {\n          throw new Error('expression must be a non-empty string.');\n        }\n\n        const visState = ctx.getVisState();\n        const datasets = visState.datasets;\n        const dataId = Object.keys(datasets).find(\n          id => id === datasetName || datasets[id].label === datasetName\n        );\n        if (!dataId) {\n          throw new Error(`Dataset \"${datasetName}\" not found.`);\n        }\n        const fieldNames = datasets[dataId].fields.map((f: any) => f.name);\n        if (copyFromColumn != null && !fieldNames.includes(copyFromColumn)) {\n          throw new Error(\n            `Column \"${copyFromColumn}\" does not exist in dataset \"${datasetName}\". ` +\n              `Existing columns: ${fieldNames.join(', ')}.`\n          );\n        }\n        if (fieldNames.includes(newColumnName)) {\n          throw new Error(\n            `Column \"${newColumnName}\" already exists in dataset \"${datasetName}\". Choose a different name.`\n          );\n        }\n\n        // Derive the DuckDB table name from the resolved dataset id, not the\n        // user-provided label: different labels can sanitize to the same table\n        // name (e.g. \"A-B\" vs \"A B\"), which would clobber another dataset's\n        // temp table inside DuckDB and run the SQL against unintended data.\n        const dbTableName = datasetNameToTableName(dataId);\n        // Pass the user-provided datasetName (label or id) to\n        // loadTableIntoDuckDB — the documented KeplerContext contract — not\n        // the resolved id.\n        const db = await ctx.loadTableIntoDuckDB(datasetName, fieldNames, dbTableName);\n\n        // Add-only: compute ONLY the new column in DuckDB. Existing columns are\n        // never round-tripped through DuckDB/Arrow — `tableFromArrays` infers a\n        // single Arrow type for `_geojson`, and a dataset mixing Polygon and\n        // MultiPolygon features gets the shallower type, so the MultiPolygon\n        // coordinates come back as nulls and the geometry disappears.\n        // `buildAddColumnPayload` rebuilds the payload from the original kepler\n        // values instead, appending the new column from this single-column result.\n        // Escape double quotes in identifier names before embedding them in\n        // quoted SQL identifiers — a `\"` in copyFromColumn/newColumnName would\n        // otherwise break the query or enable SQL injection into DuckDB. (The\n        // `expression` is user-provided SQL by design, so it is not escaped.)\n        const escapeIdent = (name: string) => name.replace(/\"/g, '\"\"');\n        const appendedSql =\n          copyFromColumn != null\n            ? `\"${escapeIdent(copyFromColumn)}\" AS \"${escapeIdent(newColumnName)}\"`\n            : `(${expression}) AS \"${escapeIdent(newColumnName)}\"`;\n        const arrowResult = await db.query(`SELECT ${appendedSql} FROM \"${dbTableName}\"`);\n\n        const {rows, fields} = buildAddColumnPayload(\n          datasets,\n          visState.layers,\n          datasetName,\n          newColumnName,\n          arrowResult\n        );\n        ctx.dispatch(updateDataset(dataId, {rows, fields} as any));\n\n        // LLM-facing preview: first 5 rows of the full (original + new) payload.\n        const previewRows = rows\n          .slice(0, 5)\n          .map(r => Object.fromEntries(fields.map((f, i) => [f.name, r[i]])));\n        const valueSource = copyFromColumn != null ? `copied from \"${copyFromColumn}\"` : `computed`;\n        return {\n          success: true,\n          commandId: addColumnCommandId,\n          data: {\n            details: `Added column \"${newColumnName}\" to dataset \"${datasetName}\" (${valueSource}, ${rows.length} rows).`,\n            addedColumns: [newColumnName],\n            firstFiveRows: tableToLLMResult(previewRows)\n          }\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: addColumnCommandId,\n          error: error instanceof Error ? error.message : String(error),\n          data: {\n            instruction: 'Please explain the error and give a plan to fix it. Then try again.'\n          }\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/cjs/commands/basemap-command.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.basemapCommandId = void 0;
+exports.getBasemapCommand = getBasemapCommand;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+var _constants = require("@kepler.gl/constants");
+var _actions = require("@kepler.gl/actions");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var basemapCommandId = exports.basemapCommandId = 'map.set-basemap';
+function getBasemapCommand(ctx) {
+  return {
+    id: basemapCommandId,
+    name: 'Set basemap',
+    group: 'Map',
+    description: 'Change the basemap style of the kepler.gl map.',
+    metadata: {
+      readOnly: false,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: _zod.z.object({
+      styleType: _zod.z["enum"](['no_map', 'dark-matter', 'positron', 'voyager', 'satellite', 'dark', 'light', 'muted', 'muted_night'])
+    }),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(_execCtx, input) {
+        var _ref, styleType;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _ref = input !== null && input !== void 0 ? input : {}, styleType = _ref.styleType;
+              _context.prev = 1;
+              if (_constants.DEFAULT_MAP_STYLES.find(function (style) {
+                return style.id === styleType;
+              })) {
+                _context.next = 4;
+                break;
+              }
+              throw new Error("Invalid basemap style: ".concat(styleType, "."));
+            case 4:
+              ctx.dispatch((0, _actions.mapStyleChange)(styleType));
+              return _context.abrupt("return", {
+                success: true,
+                commandId: basemapCommandId,
+                data: {
+                  details: "Basemap style changed to ".concat(styleType, ".")
+                }
+              });
+            case 8:
+              _context.prev = 8;
+              _context.t0 = _context["catch"](1);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: basemapCommandId,
+                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 a different basemap style.'
+                }
+              });
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 8]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cjs/commands/boundary-command.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMapBoundaryCommand = getMapBoundaryCommand;
+exports.mapBoundaryCommandId = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _zod = require("zod");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var mapBoundaryCommandId = exports.mapBoundaryCommandId = 'map.get-boundary';
+function getMapBoundaryCommand(ctx) {
+  return {
+    id: mapBoundaryCommandId,
+    name: 'Get map boundary',
+    group: 'Map',
+    description: 'Get the boundary of the map. Northwest and Southeast coordinates in [longitude, latitude] format.',
+    metadata: {
+      readOnly: true,
+      riskLevel: 'low',
+      idempotent: true
+    },
+    inputSchema: _zod.z.object({}),
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var boundary;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              boundary = ctx.getMapBoundary();
+              if (boundary) {
+                _context.next = 4;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: mapBoundaryCommandId,
+                error: 'Map boundary not available.',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map is properly loaded and try again.'
+                }
+              });
+            case 4:
+              return _context.abrupt("return", {
+                success: true,
+                commandId: mapBoundaryCommandId,
+                data: {
+                  details: "Map boundary retrieved. NW: [".concat(boundary.nw[0], ", ").concat(boundary.nw[1], "], SE: [").concat(boundary.se[0], ", ").concat(boundary.se[1], "]"),
+                  boundary: boundary
+                }
+              });
+            case 7:
+              _context.prev = 7;
+              _context.t0 = _context["catch"](0);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: mapBoundaryCommandId,
+                error: _context.t0 instanceof Error ? _context.t0.message : 'Unknown error',
+                data: {
+                  instruction: 'Please ensure the kepler.gl map is properly loaded and try again.'
+                }
+              });
+            case 10:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[0, 7]]);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/cjs/commands/command-wrappers.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asInputSchema = asInputSchema;
+exports.toolToCommand = toolToCommand;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Generic utility for converting an existing AI SDK tool into a sqlrooms
+ * `RoomCommand`. Kept dependency-light (only `zod` + `RoomCommand` type) so it
+ * can be reused by any in-browser skill system that wants to expose its
+ * existing AI SDK tools as commands without rewriting them.
+ *
+ * The demo-app's own command factories return `RoomCommand` directly (preferred
+ * when you own the command — see `basemap-command.ts` for the reference shape). This
+ * wrapper is the fallback path for hosts that cannot rewrite their tools:
+ * it folds the tool's `execute`, `inputSchema`, and `toModelOutput` (the
+ * token-trim logic the AI SDK applies between tool call and model) into a
+ * single `RoomCommand.execute` so the registry-stored result already carries
+ * the model-facing subset.
+ */
+
+/** A built AI SDK tool, treated loosely for dynamic dispatch. */
+
+/** Metadata that the AI SDK tool does not carry but a `RoomCommand` requires. */
+
+/**
+ * Cast a concrete zod schema (e.g. `z.object({...})`, which is `ZodObject<...>`)
+ * to the `ZodType<unknown>` that `RoomCommand.inputSchema` expects. The
+ * installed zod `ZodObject` is not structurally assignable to sqlrooms'
+ * `ZodType<unknown>` (covariance on the output type), so a cast is required at
+ * the assignment site. This helper centralizes that cast.
+ */
+function asInputSchema(schema) {
+  return schema;
+}
+
+/**
+ * Wrap an existing AI SDK tool as a sqlrooms `RoomCommand`. The command's
+ * `execute` calls the tool's `execute` and then applies the tool's
+ * `toModelOutput` (if any) so the trimmed, model-facing shape is what the
+ * registry stores and downstream surfaces (AI skill, palette, CLI, MCP) see.
+ */
+function toolToCommand(tool, meta) {
+  return {
+    id: meta.id,
+    name: meta.name,
+    description: tool.description,
+    group: meta.group,
+    keywords: meta.keywords,
+    inputSchema: tool.inputSchema,
+    execute: function () {
+      var _execute = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee(ctx, input) {
+        var _rawOutput$success, _ref, _ref2, rawOutput, trimmed;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (!(!tool.execute || typeof tool.execute !== 'function')) {
+                _context.next = 2;
+                break;
+              }
+              return _context.abrupt("return", {
+                success: false,
+                commandId: meta.id,
+                error: 'Tool has no execute function.'
+              });
+            case 2:
+              _context.prev = 2;
+              _context.next = 5;
+              return tool.execute(input !== null && input !== void 0 ? input : {}, {
+                toolCallId: meta.id,
+                signal: ctx.signal
+              });
+            case 5:
+              rawOutput = _context.sent;
+              trimmed = typeof tool.toModelOutput === 'function' ? tool.toModelOutput({
+                output: rawOutput,
+                toolCallId: meta.id
+              }) : rawOutput;
+              return _context.abrupt("return", {
+                success: (_rawOutput$success = rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.success) !== null && _rawOutput$success !== void 0 ? _rawOutput$success : true,
+                commandId: meta.id,
+                // A structured failure (success:false) that didn't throw must still
+                // carry an error message — otherwise callers see {success:false,
+                // error:undefined} and downstream formatters misreport it as a
+                // success. Many tool/result shapes (including RoomCommandResult)
+                // carry the failure in a `message` field rather than `error`, so
+                // fall back to that before the generic message.
+                error: (rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.success) === false ? (_ref = (_ref2 = rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.error) !== null && _ref2 !== void 0 ? _ref2 : rawOutput === null || rawOutput === void 0 ? void 0 : rawOutput.message) !== null && _ref !== void 0 ? _ref : 'Tool execution failed.' : undefined,
+                data: (0, _typeof2["default"])(trimmed) === 'object' && trimmed !== null ? trimmed : {
+                  details: trimmed
+                }
+              });
+            case 10:
+              _context.prev = 10;
+              _context.t0 = _context["catch"](2);
+              return _context.abrupt("return", {
+                success: false,
+                commandId: meta.id,
+                error: _context.t0 instanceof Error ? _context.t0.message : String(_context.t0)
+              });
+            case 13:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[2, 10]]);
+      }));
+      function execute(_x, _x2) {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["asInputSchema","schema","toolToCommand","tool","meta","id","name","description","group","keywords","inputSchema","execute","_execute","_asyncToGenerator2","_regenerator","mark","_callee","ctx","input","_rawOutput$success","_ref","_ref2","rawOutput","trimmed","wrap","_callee$","_context","prev","next","abrupt","success","commandId","error","toolCallId","signal","sent","toModelOutput","output","message","undefined","data","_typeof2","details","t0","Error","String","stop","_x","_x2","apply","arguments"],"sources":["../../../src/commands/command-wrappers.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Generic utility for converting an existing AI SDK tool into a sqlrooms\n * `RoomCommand`. Kept dependency-light (only `zod` + `RoomCommand` type) so it\n * can be reused by any in-browser skill system that wants to expose its\n * existing AI SDK tools as commands without rewriting them.\n *\n * The demo-app's own command factories return `RoomCommand` directly (preferred\n * when you own the command — see `basemap-command.ts` for the reference shape). This\n * wrapper is the fallback path for hosts that cannot rewrite their tools:\n * it folds the tool's `execute`, `inputSchema`, and `toModelOutput` (the\n * token-trim logic the AI SDK applies between tool call and model) into a\n * single `RoomCommand.execute` so the registry-stored result already carries\n * the model-facing subset.\n */\n\nimport type {RoomCommand} from './types';\nimport type {ZodType} from 'zod';\n\n/** A built AI SDK tool, treated loosely for dynamic dispatch. */\nexport type AnyTool = {\n  execute?: (args: any, options: any) => Promise<any>;\n  toModelOutput?: (params: {output: any; toolCallId?: string}) => any;\n  description?: string;\n  inputSchema?: ZodType;\n};\n\n/** Metadata that the AI SDK tool does not carry but a `RoomCommand` requires. */\nexport type CommandMeta = {\n  /** Stable, namespaced command id, e.g. `map.set-basemap`. */\n  id: string;\n  /** Human-readable name shown in the command palette / listings. */\n  name: string;\n  /** Optional grouping label, e.g. `Map`, `Data`, `GeoDa`. */\n  group?: string;\n  /** Optional search keywords. */\n  keywords?: string[];\n};\n\n/**\n * Cast a concrete zod schema (e.g. `z.object({...})`, which is `ZodObject<...>`)\n * to the `ZodType<unknown>` that `RoomCommand.inputSchema` expects. The\n * installed zod `ZodObject` is not structurally assignable to sqlrooms'\n * `ZodType<unknown>` (covariance on the output type), so a cast is required at\n * the assignment site. This helper centralizes that cast.\n */\nexport function asInputSchema(schema: ZodType): ZodType<unknown> {\n  return schema as unknown as ZodType<unknown>;\n}\n\n/**\n * Wrap an existing AI SDK tool as a sqlrooms `RoomCommand`. The command's\n * `execute` calls the tool's `execute` and then applies the tool's\n * `toModelOutput` (if any) so the trimmed, model-facing shape is what the\n * registry stores and downstream surfaces (AI skill, palette, CLI, MCP) see.\n */\nexport function toolToCommand(tool: AnyTool, meta: CommandMeta): RoomCommand {\n  return {\n    id: meta.id,\n    name: meta.name,\n    description: tool.description,\n    group: meta.group,\n    keywords: meta.keywords,\n    inputSchema: tool.inputSchema as any,\n    execute: async (ctx, input) => {\n      if (!tool.execute || typeof tool.execute !== 'function') {\n        return {\n          success: false,\n          commandId: meta.id,\n          error: 'Tool has no execute function.'\n        };\n      }\n      try {\n        // Thread the caller's AbortSignal through so hosts (WebMCP / bridge)\n        // can cancel long-running wrapped tools when the agent aborts. Tools\n        // that don't use a signal ignore it.\n        const rawOutput = await tool.execute(input ?? {}, {\n          toolCallId: meta.id,\n          signal: ctx.signal\n        });\n        const trimmed =\n          typeof tool.toModelOutput === 'function'\n            ? tool.toModelOutput({output: rawOutput, toolCallId: meta.id})\n            : rawOutput;\n        return {\n          success: rawOutput?.success ?? true,\n          commandId: meta.id,\n          // A structured failure (success:false) that didn't throw must still\n          // carry an error message — otherwise callers see {success:false,\n          // error:undefined} and downstream formatters misreport it as a\n          // success. Many tool/result shapes (including RoomCommandResult)\n          // carry the failure in a `message` field rather than `error`, so\n          // fall back to that before the generic message.\n          error:\n            rawOutput?.success === false\n              ? (rawOutput?.error as string | undefined) ??\n                (rawOutput?.message as string | undefined) ??\n                'Tool execution failed.'\n              : undefined,\n          data: typeof trimmed === 'object' && trimmed !== null ? trimmed : {details: trimmed}\n        };\n      } catch (error) {\n        return {\n          success: false,\n          commandId: meta.id,\n          error: error instanceof Error ? error.message : String(error)\n        };\n      }\n    }\n  };\n}\n"],"mappings":"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","ignoreList":[]}