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

package/dist/commands/utils.d.ts

@@ -0,0 +1,138 @@
+import type { Layer, VectorTileLayer } from '@kepler.gl/layers';
+import type { Datasets } from '@kepler.gl/table';
+import type { Field } from '@kepler.gl/types';
+/** Type for a Redux dispatch function, used by tools that need to dispatch kepler actions */
+export type KeplerDispatch = (action: any) => void;
+/**
+ * Deterministically convert a dataset name into a valid DuckDB table name.
+ * Replaces non-alphanumeric characters (except underscores) with underscores,
+ * collapses consecutive underscores, trims leading/trailing underscores,
+ * lowercases the result, and prepends 'tbl_' to avoid reserved-word collisions.
+ */
+export declare function datasetNameToTableName(datasetName: string): string;
+/**
+ * Recursively convert an Arrow row (which uses proxy objects) into a plain JS
+ * object. Handles nested toJSON(), arrays, and bigint values. Extracted from
+ * query-tool.ts so the stock @sqlrooms/ai query tool wrapper can share it.
+ */
+export declare function convertArrowRowToObject(row: any): unknown;
+/**
+ * Convert an Arrow Table to an array of plain JS objects.
+ *
+ * Decimal columns are resolved to numbers using each column's declared scale.
+ * `row.toJSON()` passes Decimal values through as opaque BigNum objects
+ * ({0: low, 1: high, ...}), which kepler.gl then stores as `object`-typed
+ * fields and downstream commands (e.g. `data.merge-tables`) choke on when they
+ * try to re-materialize the dataset into DuckDB. The schema carries the scale,
+ * so we resolve the value here.
+ */
+export declare function arrowTableToObjects(table: {
+    toArray: () => any[];
+    schema?: {
+        fields: {
+            name: string;
+            type?: {
+                typeId?: number;
+                scale?: number;
+            };
+        }[];
+    };
+}): Record<string, unknown>[];
+/**
+ * Read a column's values from a kepler dataset (by dataset label + field name).
+ * Vectors through the vector-tile layer when the dataset is a vector-tile
+ * dataset (whose values live in the layer's tile set, not the kepler table).
+ *
+ * Moved in from kepler-assistant's `src/glue/utils.ts` so this package is
+ * self-contained — the map.* commands that call this seam (via `KeplerContext`)
+ * cannot import from kepler-assistant (that would be circular).
+ */
+export declare function getValuesFromDataset(datasets: Datasets, layers: Layer[], datasetName: string, variableName: string): unknown[];
+export declare function isVectorTileLayer(layer: Layer): layer is VectorTileLayer;
+export declare function getValuesFromVectorTileLayer(datasetId: string, layers: Layer[], field: Field): unknown[];
+/**
+ * Whether a column holds any non-null object value — e.g. the `_geojson` column,
+ * which stores whole GeoJSON Feature objects. Such columns must NOT be handed to
+ * `tableFromArrays` raw: Arrow infers ONE type per column from the first value,
+ * and a dataset mixing Polygon (depth-3 `coordinates`) and MultiPolygon (depth-4)
+ * features gets the shallower type, so the MultiPolygon coordinates come back as
+ * `null` and the geometry disappears. Serialize them to JSON strings for the
+ * DuckDB round-trip and restore with `restoreObjectColumns`.
+ */
+export declare function isObjectColumn(values: unknown[]): boolean;
+/**
+ * Serialize object values to JSON strings (nulls/primitives pass through
+ * unchanged) so `tableFromArrays` never has to infer a nested-struct type.
+ */
+export declare function stringifyObjectColumn(values: unknown[]): unknown[];
+/**
+ * Restore object-valued columns that `stringifyObjectColumn` serialized back to
+ * their object form, in place. Used after a DuckDB query returns those columns
+ * as JSON strings (e.g. `_geojson` after `SELECT *`).
+ */
+export declare function restoreObjectColumns(rows: Record<string, unknown>[], columnNames: string[]): void;
+/**
+ * Build an `updateDataset` payload that appends ONE new column to an existing
+ * kepler dataset, keeping every existing column byte-for-byte identical.
+ *
+ * Existing columns are read straight from the kepler dataset (via
+ * `getValuesFromDataset`) and NEVER round-tripped through Arrow/DuckDB. That
+ * matters for `_geojson`: `tableFromArrays` infers a single Arrow type for the
+ * whole column, and a dataset mixing Polygon and MultiPolygon features gets the
+ * shallower type — the MultiPolygon's deeper coordinate nesting comes back as
+ * nulls and the geometry disappears. Only the NEW column's values come from the
+ * computation (DuckDB expression / copy, or geoda write-back).
+ *
+ * @param datasets kepler datasets (visState.datasets)
+ * @param layers kepler layers (visState.layers) — needed for vector-tile datasets
+ * @param datasetName the dataset label
+ * @param newColumnName name of the column being appended
+ * @param newColumnArrow single-column arrow table holding the new column's values
+ * @returns an `updateDataset` `data` payload: `{rows, fields}`
+ */
+export declare function buildAddColumnPayload(datasets: Datasets, layers: Layer[], datasetName: string, newColumnName: string, newColumnArrow: any): {
+    rows: unknown[][];
+    fields: any[];
+};
+/**
+ * Default number of first rows to format and return to the LLM as a preview.
+ * Mirrors spatial-agent's NUMBER_OF_ROWS_RETURN_TO_LLM.
+ */
+export declare const NUMBER_OF_ROWS_RETURN_TO_LLM = 5;
+/**
+ * Default total character budget for the LLM-facing preview. Capped at ~1000
+ * chars so the preview stays small in context, matching spatial-agent's
+ * formatResultsForLLM default.
+ */
+export declare const LLM_PREVIEW_MAX_TOTAL_LENGTH = 1000;
+export declare const LLM_PREVIEW_MAX_VALUE_LENGTH = 80;
+/**
+ * Format a query result table as a pipe-delimited string suitable for LLM
+ * consumption. Truncates individual cell values and total output to stay within
+ * a token budget. Shared by the stock @sqlrooms/ai query tool wrapper and the
+ * skill executeApi data.query path.
+ */
+export declare function tableToLLMResult(table: Record<string, unknown>[], maxTotalLength?: number, maxValueLength?: number): string;
+/**
+ * Format the first N rows of an Arrow result as a pipe-delimited string for the
+ * LLM, capped at maxTotalLength chars. Convenience wrapper combining
+ * arrowTableToObjects + tableToLLMResult: slices the first `numberOfRows`
+ * rows, normalizes Decimal columns via arrowTableToObjects (applying each
+ * column's declared scale so previews don't leak opaque BigNum word objects),
+ * then renders the pipe table.
+ */
+export declare function formatResultsForLLM(result: {
+    toArray: () => any[];
+    schema?: {
+        fields: {
+            name: string;
+            type?: {
+                typeId?: number;
+                scale?: number;
+            };
+        }[];
+    };
+}, numberOfRows?: number, options?: {
+    maxTotalLength?: number;
+    maxValueLength?: number;
+}): string;

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

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

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

@@ -0,0 +1,185 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+import { updateDataset } from '@kepler.gl/actions';
+import { buildAddColumnPayload } from './utils';
+import { datasetNameToTableName, tableToLLMResult } from './utils';
+export var addColumnCommandId = 'map.add-column';
+export 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: z.object({
+      datasetName: z.string().min(1).describe('The name (label) or id of the dataset to add the column to'),
+      newColumnName: z.string().min(1).describe('The name of the new column to add. Must not already exist in the dataset.'),
+      copyFromColumn: 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: 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: z.ZodIssueCode.custom,
+          message: 'Provide exactly one of copyFromColumn or expression.'
+        });
+      }
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.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 _regeneratorRuntime.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 = 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 = buildAddColumnPayload(datasets, visState.layers, datasetName, newColumnName, arrowResult), rows = _buildAddColumnPayloa.rows, fields = _buildAddColumnPayloa.fields;
+              ctx.dispatch(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: 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":["z","updateDataset","buildAddColumnPayload","datasetNameToTableName","tableToLLMResult","addColumnCommandId","getAddColumnCommand","ctx","id","name","group","description","metadata","readOnly","riskLevel","idempotent","inputSchema","object","datasetName","string","min","describe","newColumnName","copyFromColumn","optional","expression","superRefine","data","provided","filter","v","length","addIssue","code","ZodIssueCode","custom","message","execute","_execute","_asyncToGenerator","_regeneratorRuntime","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","loadTableIntoDuckDB","sent","replace","query","layers","dispatch","slice","r","fromEntries","i","abrupt","success","commandId","details","addedColumns","firstFiveRows","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/esm/commands/basemap-command.js

@@ -0,0 +1,72 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+import { DEFAULT_MAP_STYLES } from '@kepler.gl/constants';
+import { mapStyleChange } from '@kepler.gl/actions';
+export var basemapCommandId = 'map.set-basemap';
+export 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: z.object({
+      styleType: z["enum"](['no_map', 'dark-matter', 'positron', 'voyager', 'satellite', 'dark', 'light', 'muted', 'muted_night'])
+    }),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(_execCtx, input) {
+        var _ref, styleType;
+        return _regeneratorRuntime.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 (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(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/esm/commands/boundary-command.js

@@ -0,0 +1,73 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { z } from 'zod';
+export var mapBoundaryCommandId = 'map.get-boundary';
+export 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: z.object({}),
+    execute: function () {
+      var _execute = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+        var boundary;
+        return _regeneratorRuntime.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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