@pixerate/editor 0.44.0 → 0.45.0

package/dist/agent/index.cjs

@@ -10,20 +10,39 @@
 
 
 
-var _chunkV7CC7RZ6cjs = require('../chunk-V7CC7RZ6.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkK2LVZ4FAcjs = require('../chunk-K2LVZ4FA.cjs');
 
 
 var _chunkHXDMZQTDcjs = require('../chunk-HXDMZQTD.cjs');
 
 
-var _chunkI6BZB5ZHcjs = require('../chunk-I6BZB5ZH.cjs');
+var _chunkEFDCLENWcjs = require('../chunk-EFDCLENW.cjs');
 
 
 
 
 
 
-var _chunkMC2LQN5Scjs = require('../chunk-MC2LQN5S.cjs');
+
+
+var _chunkJ3R2OWOEcjs = require('../chunk-J3R2OWOE.cjs');
 
 
 
@@ -63,8 +82,8 @@ function planAgentCommand(command, snapshot, options = {}) {
   const defaultNodeSize = _nullishCoalesce(options.defaultNodeSize, () => ( { width: 200, height: 60 }));
   const idGen = _nullishCoalesce(options.idGenerator, () => ( (() => `node-${Math.random().toString(36).substring(2, 9)}`)));
   const edgeIdGen = () => `edge-${Math.random().toString(36).substring(2, 9)}`;
-  const nodes = _nullishCoalesce(_optionalChain([snapshot, 'access', _ => _.canvas, 'optionalAccess', _2 => _2.nodes]), () => ( []));
-  const edges = _nullishCoalesce(_optionalChain([snapshot, 'access', _3 => _3.canvas, 'optionalAccess', _4 => _4.edges]), () => ( []));
+  const nodes = _nullishCoalesce(_optionalChain([snapshot, 'access', _2 => _2.canvas, 'optionalAccess', _3 => _3.nodes]), () => ( []));
+  const edges = _nullishCoalesce(_optionalChain([snapshot, 'access', _4 => _4.canvas, 'optionalAccess', _5 => _5.edges]), () => ( []));
   switch (command.type) {
     case "canvas:add_node": {
       let pos = command.node.position;
@@ -75,8 +94,8 @@ function planAgentCommand(command, snapshot, options = {}) {
           rects[n.id] = {
             x: n.position.x,
             y: n.position.y,
-            width: _nullishCoalesce(_nullishCoalesce(_optionalChain([n, 'access', _5 => _5.measured, 'optionalAccess', _6 => _6.width]), () => ( n.width)), () => ( defaultNodeSize.width)),
-            height: _nullishCoalesce(_nullishCoalesce(_optionalChain([n, 'access', _7 => _7.measured, 'optionalAccess', _8 => _8.height]), () => ( n.height)), () => ( defaultNodeSize.height))
+            width: _nullishCoalesce(_nullishCoalesce(_optionalChain([n, 'access', _6 => _6.measured, 'optionalAccess', _7 => _7.width]), () => ( n.width)), () => ( defaultNodeSize.width)),
+            height: _nullishCoalesce(_nullishCoalesce(_optionalChain([n, 'access', _8 => _8.measured, 'optionalAccess', _9 => _9.height]), () => ( n.height)), () => ( defaultNodeSize.height))
           };
         }
         if (anchorId) {
@@ -256,33 +275,60 @@ function planAgentCommand(command, snapshot, options = {}) {
     }
   }
 }
+var CANVAS_TOOL_OPERATIONS = {
+  canvas_add_node: "add_node",
+  canvas_remove_nodes: "remove_nodes",
+  canvas_connect: "connect",
+  canvas_update_node: "update_node",
+  canvas_layout: "layout",
+  canvas_select: "select",
+  canvas_highlight: "highlight"
+};
+var PROMPT_TOOL_OPERATIONS = {
+  prompt_insert_text: "insert_text",
+  prompt_replace_range: "replace_range",
+  prompt_set_variable: "set_variable",
+  prompt_select: "select"
+};
 function toolCallToAgentCommand(name, args = {}) {
   const ids = (value) => Array.isArray(value) && value.every((v) => typeof v === "string") ? value : null;
   const num = (value) => typeof value === "number" && Number.isFinite(value);
-  if (name === "edit_canvas") {
-    switch (args.operation) {
+  const canvasOperation = name === "edit_canvas" ? args.operation : CANVAS_TOOL_OPERATIONS[name];
+  if (canvasOperation !== void 0) {
+    switch (canvasOperation) {
       case "add_node":
-        return args.node && typeof args.node === "object" ? { type: "canvas:add_node", node: args.node, nearNodeId: args.nearNodeId, side: args.side } : null;
+        return args.node && typeof args.node === "object" && !Array.isArray(args.node) ? {
+          type: "canvas:add_node",
+          node: { ...args.node, data: _nullishCoalesce(args.node.data, () => ( {})) },
+          nearNodeId: args.nearNodeId,
+          side: args.side
+        } : null;
       case "remove_nodes":
         return ids(args.nodeIds) ? { type: "canvas:remove_nodes", nodeIds: args.nodeIds } : null;
       case "connect":
         return typeof args.source === "string" && typeof args.target === "string" ? { type: "canvas:connect", source: args.source, target: args.target, label: args.label } : null;
       case "update_node": {
-        const id = _nullishCoalesce(_optionalChain([args, 'access', _9 => _9.node, 'optionalAccess', _10 => _10.id]), () => ( args.id));
-        return typeof id === "string" ? { type: "canvas:update_node", id, data: _nullishCoalesce(_nullishCoalesce(_optionalChain([args, 'access', _11 => _11.node, 'optionalAccess', _12 => _12.data]), () => ( args.data)), () => ( {})) } : null;
+        const id = _nullishCoalesce(_optionalChain([args, 'access', _10 => _10.node, 'optionalAccess', _11 => _11.id]), () => ( args.id));
+        return typeof id === "string" ? { type: "canvas:update_node", id, data: _nullishCoalesce(_nullishCoalesce(_optionalChain([args, 'access', _12 => _12.node, 'optionalAccess', _13 => _13.data]), () => ( args.data)), () => ( {})) } : null;
       }
       case "layout":
         return { type: "canvas:layout", direction: args.direction, incremental: args.incremental };
       case "select":
         return ids(args.nodeIds) ? { type: "canvas:select", nodeIds: args.nodeIds } : null;
       case "highlight":
-        return ids(args.nodeIds) ? { type: "canvas:highlight", nodeIds: args.nodeIds } : null;
+        return ids(args.nodeIds) ? {
+          type: "canvas:highlight",
+          nodeIds: args.nodeIds,
+          ...typeof args.color === "string" ? { color: args.color } : {},
+          ...num(args.durationMs) ? { durationMs: args.durationMs } : {}
+        } : null;
       default:
         return null;
     }
   }
-  if (name === "edit_prompt") {
-    switch (args.operation) {
+  const promptOperation = name === "edit_prompt" ? args.operation : PROMPT_TOOL_OPERATIONS[name];
+  if (promptOperation !== void 0) {
+    switch (promptOperation) {
       case "insert_text":
         return typeof args.text === "string" ? { type: "prompt:insert_text", text: args.text, at: num(args.at) ? args.at : void 0 } : null;
       case "replace_range":
@@ -297,6 +343,42 @@ function toolCallToAgentCommand(name, args = {}) {
   }
   return { type: "tool:call", name, arguments: args };
 }
+function validateAgentCommand(command, snapshot) {
+  const known = new Set((_nullishCoalesce(_optionalChain([snapshot, 'access', _14 => _14.canvas, 'optionalAccess', _15 => _15.nodes]), () => ( []))).map((n) => n.id));
+  const missing = (nodeIds) => {
+    const unknown = nodeIds.filter((id) => !known.has(id));
+    return unknown.length ? `Unknown node id${unknown.length > 1 ? "s" : ""}: ${unknown.map((id) => JSON.stringify(id)).join(", ")}. Call get_editor_state for the current ids.` : null;
+  };
+  const range = (from, to) => {
+    if (from < 0 || to < 0) return "Positions must be >= 0.";
+    if (from > to) return `"from" (${from}) must not be after "to" (${to}).`;
+    return null;
+  };
+  switch (command.type) {
+    case "canvas:add_node":
+      if (command.node.id && known.has(command.node.id)) return `A node with id "${command.node.id}" already exists.`;
+      return command.nearNodeId ? missing([command.nearNodeId]) : null;
+    case "canvas:remove_nodes":
+    case "canvas:highlight":
+      return command.nodeIds.length ? missing(command.nodeIds) : "Pass at least one node id.";
+    case "canvas:select":
+      return missing(command.nodeIds);
+    case "canvas:connect":
+      if (command.source === command.target) return "An edge needs two different nodes.";
+      return missing([command.source, command.target]);
+    case "canvas:update_node":
+      return missing([command.id]);
+    case "prompt:insert_text":
+      return command.at !== void 0 ? range(command.at, command.at) : null;
+    case "prompt:replace_range":
+    case "prompt:select":
+      return range(command.from, command.to);
+    case "choreography:say":
+      return command.atNodeId ? missing([command.atNodeId]) : null;
+    default:
+      return null;
+  }
+}
 function planToolCall(name, args, snapshot, options) {
   const command = toolCallToAgentCommand(name, args);
   return command ? planAgentCommand(command, snapshot, options) : [];
@@ -314,12 +396,45 @@ function selectionInfo(editor) {
   const { from, to } = editor.state.selection;
   return { from, to, text: editor.state.doc.textBetween(from, to, "\n") };
 }
+function checkRange(editor, from, to) {
+  const size = editor.state.doc.content.size;
+  if (from > to) throw new Error(`"from" (${from}) must not be after "to" (${to}).`);
+  if (to > size) throw new Error(`Position ${to} is outside the document (size ${size}).`);
+}
+function textBlocks(editor) {
+  const blocks = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (!node.isTextblock) return true;
+    blocks.push({ type: node.type.name, from: pos + 1, to: pos + 1 + node.content.size, text: node.textContent });
+    return false;
+  });
+  return blocks;
+}
+var FIND_SCHEMA_PROPERTIES = {
+  matchCase: { type: "boolean", description: "Case-sensitive match (default false)." },
+  wholeWord: { type: "boolean", description: "Match whole words only (default false)." },
+  regex: {
+    type: "boolean",
+    description: "Treat the query as a JavaScript regular expression (default false: literal text)."
+  }
+};
+var CONTEXT_CHARS = 30;
+function findMatches(editor, query, args, replacement) {
+  const options = {
+    matchCase: !!args.matchCase,
+    wholeWord: !!args.wholeWord,
+    ...args.regex ? { regex: true } : { literal: true }
+  };
+  const result = _chunkJ3R2OWOEcjs.searchDocument.call(void 0, editor.state.doc, query, options, replacement !== void 0 ? { replacement } : {});
+  if (result.error) throw new Error(`Invalid search pattern: ${result.error.message}`);
+  return { matches: result.matches, truncated: result.truncated };
+}
 function createRichTextToolProvider(target, options) {
   const editor = () => toEditor(target);
   const getText = {
     name: "get_text",
     title: "Get document text",
-    description: "Returns the document content (plain text by default, or HTML / markdown) and the current selection.",
+    description: "Returns the document content (plain text by default, or HTML / markdown), the current selection and the document size. Editing tools take document positions, not text offsets: pass `blocks: true` to get every paragraph with the positions its text spans, or use find_text to get the positions of a phrase.",
     inputSchema: {
       type: "object",
       properties: {
@@ -327,6 +442,10 @@ function createRichTextToolProvider(target, options) {
           type: "string",
           enum: ["text", "html", "markdown"],
           description: "Content format (default: text)."
+        },
+        blocks: {
+          type: "boolean",
+          description: "Also return `blocks`: each paragraph/heading/cell as {type, from, to, text} (default false)."
         }
       },
       additionalProperties: false
@@ -338,10 +457,16 @@ function createRichTextToolProvider(target, options) {
       idempotentHint: true,
       openWorldHint: false
     },
-    handler: ({ format = "text" }) => {
+    handler: ({ format = "text", blocks = false }) => {
       const ed = editor();
       const content = format === "html" ? ed.getHTML() : format === "markdown" ? _chunk66IMF6ODcjs.getEditorMarkdown.call(void 0, ed) : _chunk66IMF6ODcjs.getEditorText.call(void 0, ed);
-      return { format, content, selection: selectionInfo(ed), size: ed.state.doc.content.size };
+      return {
+        format,
+        content,
+        selection: selectionInfo(ed),
+        size: ed.state.doc.content.size,
+        ...blocks ? { blocks: textBlocks(ed) } : {}
+      };
     }
   };
   const insertText = {
@@ -375,6 +500,148 @@ function createRichTextToolProvider(target, options) {
       return { inserted: text.length, selection: selectionInfo(ed) };
     }
   };
+  const findText = {
+    name: "find_text",
+    title: "Find text",
+    description: "Finds a phrase (literal by default) and returns each match with its document positions {from, to}, ready for replace_range, insert_text `at` or set_selection, plus surrounding context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 1, description: "Text (or regex) to find." },
+        ...FIND_SCHEMA_PROPERTIES,
+        maxResults: { type: "integer", minimum: 1, maximum: 500, description: "Matches returned (default 50)." }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Find text",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: ({ query, maxResults = 50, ...flags }) => {
+      const ed = editor();
+      const { doc } = ed.state;
+      const { matches, truncated } = findMatches(ed, query, flags);
+      return {
+        total: matches.length,
+        truncated: truncated || matches.length > maxResults,
+        matches: matches.slice(0, maxResults).map((m) => ({
+          from: m.from,
+          to: m.to,
+          text: m.text,
+          before: doc.textBetween(Math.max(0, m.from - CONTEXT_CHARS), m.from, "\n", " "),
+          after: doc.textBetween(m.to, Math.min(doc.content.size, m.to + CONTEXT_CHARS), "\n", " ")
+        }))
+      };
+    }
+  };
+  const replaceText = {
+    name: "replace_text",
+    title: "Find and replace",
+    description: "Replaces occurrences of a phrase with literal text in one undoable step, keeping the found text's formatting. Replaces every occurrence by default, or only the n-th with `occurrence`. Fails when nothing matches.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        find: { type: "string", minLength: 1, description: "Text (or regex) to find." },
+        replace: { type: "string", description: "Replacement text (literal; an empty string deletes the matches)." },
+        ...FIND_SCHEMA_PROPERTIES,
+        occurrence: {
+          type: "integer",
+          minimum: 1,
+          description: "Only replace the n-th match (1-based, in document order). Default: all matches."
+        }
+      },
+      required: ["find", "replace"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Find and replace",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: ({ find, replace, occurrence, ...flags }) => {
+      const ed = editor();
+      const { matches } = findMatches(ed, find, flags);
+      if (matches.length === 0) throw new Error(`No match for ${JSON.stringify(find)}.`);
+      if (occurrence !== void 0 && occurrence > matches.length) {
+        throw new Error(`Occurrence ${occurrence} requested, but there are only ${matches.length} matches.`);
+      }
+      const chosen = (occurrence !== void 0 ? [matches[occurrence - 1]] : matches).map((m) => ({
+        ...m,
+        replacement: String(replace).replace(/\r\n?|\n/g, "\r")
+      }));
+      const tr = ed.state.tr;
+      const ends = _chunkJ3R2OWOEcjs.applyReplacements.call(void 0, tr, chosen);
+      ed.view.dispatch(tr.scrollIntoView());
+      return {
+        replaced: chosen.length,
+        total: matches.length,
+        ranges: chosen.map((m, i) => ({ from: tr.mapping.map(m.from, -1), to: ends[i] })),
+        selection: selectionInfo(ed)
+      };
+    }
+  };
+  const replaceRange = {
+    name: "replace_range",
+    title: "Replace a range",
+    description: "Replaces the content between two document positions (from get_text `blocks` or find_text) with literal text. from === to inserts; an empty text deletes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "integer", minimum: 0, description: "Start document position." },
+        to: { type: "integer", minimum: 0, description: "End document position." },
+        text: { type: "string", description: "Replacement text (newlines start new paragraphs)." }
+      },
+      required: ["from", "to", "text"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Replace a range",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: ({ from, to, text }) => {
+      const ed = editor();
+      checkRange(ed, from, to);
+      replaceWithText(ed, from, to, text);
+      return { replaced: { from, to }, selection: selectionInfo(ed), size: ed.state.doc.content.size };
+    }
+  };
+  const setSelection = {
+    name: "set_selection",
+    title: "Set the selection",
+    description: "Selects the content between two document positions (from === to places the cursor).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "integer", minimum: 0, description: "Start document position." },
+        to: { type: "integer", minimum: 0, description: "End document position (default: from)." }
+      },
+      required: ["from"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Set the selection",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: ({ from, to = from }) => {
+      const ed = editor();
+      checkRange(ed, from, to);
+      const { doc } = ed.state;
+      ed.view.dispatch(ed.state.tr.setSelection(_state.TextSelection.between(doc.resolve(from), doc.resolve(to))));
+      return { selection: selectionInfo(ed) };
+    }
+  };
   const replaceSelection = {
     name: "replace_selection",
     title: "Replace selection",
@@ -406,7 +673,7 @@ function createRichTextToolProvider(target, options) {
     inputSchema: {
       type: "object",
       properties: {
-        operation: { type: "string", enum: _chunkMC2LQN5Scjs.TABLE_ACTIONS.map((a) => a.action), description: "Table operation." },
+        operation: { type: "string", enum: _chunkJ3R2OWOEcjs.TABLE_ACTIONS.map((a) => a.action), description: "Table operation." },
         at: { type: "integer", minimum: 0, description: "Document position to place the cursor first (e.g. inside a cell)." },
         rows: { type: "integer", minimum: 1, maximum: 100, description: "insertTable: rows (default 3)." },
         cols: { type: "integer", minimum: 1, maximum: 50, description: "insertTable: columns (default 3)." },
@@ -436,10 +703,10 @@ function createRichTextToolProvider(target, options) {
         ed.view.dispatch(ed.state.tr.setSelection(_state.TextSelection.near(ed.state.doc.resolve(at))));
       }
       const action = operation;
-      const state = _chunkMC2LQN5Scjs.getTableActionState.call(void 0, ed, action, params);
+      const state = _chunkJ3R2OWOEcjs.getTableActionState.call(void 0, ed, action, params);
       if (state !== true) throw new Error(state);
-      _chunkMC2LQN5Scjs.runTableAction.call(void 0, ed, action, params);
-      const table = _chunkMC2LQN5Scjs.getTableState.call(void 0, ed);
+      _chunkJ3R2OWOEcjs.runTableAction.call(void 0, ed, action, params);
+      const table = _chunkJ3R2OWOEcjs.getTableState.call(void 0, ed);
       return {
         operation,
         table: table.inTable ? { rows: table.rows, columns: table.columns, row: table.row, column: table.column } : null,
@@ -453,8 +720,9 @@ function createRichTextToolProvider(target, options) {
     tools: () => {
       const ed = editor();
       if (!ed || ed.isDestroyed) return [];
-      if (!ed.isEditable) return [getText];
-      return _chunkMC2LQN5Scjs.isTableEnabled.call(void 0, ed) ? [getText, insertText, replaceSelection, editTable] : [getText, insertText, replaceSelection];
+      if (!ed.isEditable) return [getText, findText];
+      const tools = [getText, findText, insertText, replaceText, replaceRange, replaceSelection, setSelection];
+      return _chunkJ3R2OWOEcjs.isTableEnabled.call(void 0, ed) ? [...tools, editTable] : tools;
     },
     subscribe: (notify) => {
       const ed = editor();
@@ -473,6 +741,12 @@ function parseCell(ref) {
   if (!match) throw new Error(`Invalid cell reference "${ref}". Use A1 notation, e.g. "B3".`);
   return { col: _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, match[1].toUpperCase()), row: parseInt(match[2], 10) - 1 };
 }
+var COLUMN_REGEX = /^[A-Za-z]{1,3}$/;
+function parseColumn(name) {
+  if (!COLUMN_REGEX.test(name.trim())) throw new Error(`Invalid column "${name}". Use a letter name, e.g. "C".`);
+  return _chunkEWCOFSCQcjs.colNameToIndex.call(void 0, name.trim().toUpperCase());
+}
+var CELL_INPUT = { type: ["string", "number", "boolean", "null"] };
 function createSpreadsheetToolProvider(controller, options) {
   const lookup = (row, col) => {
     const rowDef = controller.document.rows[row];
@@ -567,20 +841,187 @@ function createSpreadsheetToolProvider(controller, options) {
       return { cell: cell.toUpperCase(), raw: updated.raw, value: _nullishCoalesce(updated.error, () => ( updated.value)) };
     }
   };
-  return { id: options.id, namespace: options.namespace, tools: [getRange, setCell] };
+  const isReadOnly = (row, col) => {
+    const found = lookup(row, col);
+    if (!found) return false;
+    const { rowDef, colDef } = found;
+    return !!(colDef.readOnly || colDef.type === "formula" || controller.getCell(rowDef.id, colDef.id).readOnly);
+  };
+  const setRange = {
+    name: "set_range",
+    title: "Set a block of cells",
+    description: 'Writes a 2D block of raw inputs starting at a cell (A1 notation), row by row, as one undo step. Values starting with "=" are formulas; null or "" clears a cell. The sheet grows to fit. Fails without writing anything if any target cell is read-only.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        start: { type: "string", description: 'Top-left cell, e.g. "A1".' },
+        values: {
+          type: "array",
+          minItems: 1,
+          maxItems: 1e4,
+          items: { type: "array", items: CELL_INPUT, maxItems: 1e3 },
+          description: 'Rows of raw cell inputs, e.g. [["Name", "Total"], ["A", "=B3*2"]].'
+        }
+      },
+      required: ["start", "values"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Set a block of cells",
+      readOnlyHint: false,
+      destructiveHint: true,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: ({ start, values }) => {
+      const { row, col } = parseCell(start);
+      const rows = values;
+      const readOnly = [];
+      rows.forEach(
+        (line, r) => line.forEach((_, c) => {
+          if (isReadOnly(row + r, col + c)) readOnly.push(`${_chunkEWCOFSCQcjs.indexToColName.call(void 0, col + c)}${row + r + 1}`);
+        })
+      );
+      if (readOnly.length) throw new Error(`Read-only cells: ${readOnly.slice(0, 20).join(", ")}. Nothing was written.`);
+      controller.importRows(
+        rows.map((line) => line.map((v) => v === null ? "" : String(v))),
+        { startRow: row, startCol: col }
+      );
+      const width = Math.max(0, ...rows.map((line) => line.length));
+      const end = `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, col + Math.max(width, 1) - 1)}${row + rows.length}`;
+      const errors = [];
+      rows.forEach(
+        (line, r) => line.forEach((_, c) => {
+          const found = lookup(row + r, col + c);
+          if (!found) return;
+          const cell = controller.getCell(found.rowDef.id, found.colDef.id);
+          const error = _nullishCoalesce(cell.error, () => ( (_chunkEWCOFSCQcjs.isFormulaError.call(void 0, cell.value) ? cell.value : void 0)));
+          if (error) errors.push({ cell: `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, col + c)}${row + r + 1}`, error: String(error) });
+        })
+      );
+      return {
+        range: `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, col)}${row + 1}:${end}`,
+        written: rows.reduce((n, line) => n + line.length, 0),
+        errors,
+        sheet: { rows: controller.document.rows.length, columns: controller.document.columns.length }
+      };
+    }
+  };
+  const COUNT = { type: "integer", minimum: 1, maximum: 1e3, description: "How many (default 1)." };
+  const sheetSize = () => ({ rows: controller.document.rows.length, columns: controller.document.columns.length });
+  const structural = (name, title, description, properties, required, destructive, handler) => ({
+    name,
+    title,
+    description,
+    inputSchema: { type: "object", properties, required, additionalProperties: false },
+    annotations: { title, readOnlyHint: false, destructiveHint: destructive, idempotentHint: false, openWorldHint: false },
+    handler
+  });
+  const insertRows = structural(
+    "insert_rows",
+    "Insert rows",
+    "Inserts empty rows before a row number (1-based; one past the last row appends). References below shift down.",
+    { before: { type: "integer", minimum: 1, description: "Row number to insert before." }, count: COUNT },
+    ["before"],
+    false,
+    ({ before, count = 1 }) => {
+      const index = before - 1;
+      if (index > controller.document.rows.length) throw new Error(`Row ${before} is past the end of the sheet (${controller.document.rows.length} rows).`);
+      for (let i = 0; i < count; i++) controller.insertRow(index);
+      return { inserted: count, rows: `${before}:${before + count - 1}`, sheet: sheetSize() };
+    }
+  );
+  const deleteRows = structural(
+    "delete_rows",
+    "Delete rows",
+    "Deletes rows starting at a row number (1-based) with their contents. References below shift up; references to deleted cells become #REF!.",
+    { start: { type: "integer", minimum: 1, description: "First row number to delete." }, count: COUNT },
+    ["start"],
+    true,
+    ({ start, count = 1 }) => {
+      const rows = controller.document.rows.slice(start - 1, start - 1 + count);
+      if (rows.length < count) throw new Error(`Rows ${start}-${start + count - 1} are not all in the sheet (${controller.document.rows.length} rows).`);
+      for (const row of rows) controller.deleteRow(row.id);
+      return { deleted: count, sheet: sheetSize() };
+    }
+  );
+  const insertColumns = structural(
+    "insert_columns",
+    "Insert columns",
+    "Inserts empty columns before a column letter (one past the last column appends). References to the right shift.",
+    { before: { type: "string", description: 'Column letter to insert before, e.g. "C".' }, count: COUNT },
+    ["before"],
+    false,
+    ({ before, count = 1 }) => {
+      const index = parseColumn(before);
+      if (index > controller.document.columns.length) throw new Error(`Column ${before} is past the end of the sheet (${controller.document.columns.length} columns).`);
+      for (let i = 0; i < count; i++) controller.insertColumn(index);
+      return { inserted: count, columns: `${_chunkEWCOFSCQcjs.indexToColName.call(void 0, index)}:${_chunkEWCOFSCQcjs.indexToColName.call(void 0, index + count - 1)}`, sheet: sheetSize() };
+    }
+  );
+  const deleteColumns = structural(
+    "delete_columns",
+    "Delete columns",
+    "Deletes columns starting at a column letter with their contents. References to the right shift left; references to deleted cells become #REF!.",
+    { start: { type: "string", description: 'First column letter to delete, e.g. "C".' }, count: COUNT },
+    ["start"],
+    true,
+    ({ start, count = 1 }) => {
+      const index = parseColumn(start);
+      const columns = controller.document.columns.slice(index, index + count);
+      if (columns.length < count) throw new Error(`Columns from ${start} (${count}) are not all in the sheet (${controller.document.columns.length} columns).`);
+      for (const column of columns) controller.deleteColumn(column.id);
+      return { deleted: count, sheet: sheetSize() };
+    }
+  );
+  return {
+    id: options.id,
+    namespace: options.namespace,
+    tools: [getRange, setCell, setRange, insertRows, deleteRows, insertColumns, deleteColumns]
+  };
+}
+function missingArgumentsMessage(name, args) {
+  const required = _chunkK2LVZ4FAcjs.EDIT_OPERATION_REQUIRED_ARGUMENTS[name][args.operation];
+  if (!required) return `Unknown operation "${args.operation}".`;
+  const missing = required.filter(
+    (key) => key === "id" ? args.id === void 0 && _optionalChain([args, 'access', _16 => _16.node, 'optionalAccess', _17 => _17.id]) === void 0 : args[key] === void 0
+  );
+  return missing.length ? `Operation "${args.operation}" requires ${required.join(", ")}; missing: ${missing.join(", ")}.` : `Operation "${args.operation}" has invalid arguments (expected ${required.join(", ")} with the types in the schema).`;
+}
+function describeSteps(steps) {
+  const nodes = [];
+  const edges = [];
+  for (const step of steps) {
+    if (step.type === "step:canvas_add_node") nodes.push({ id: step.node.id, position: step.node.position });
+    if (step.type === "step:canvas_add_edge") edges.push({ id: step.edge.id, source: step.edge.source, target: step.edge.target });
+  }
+  return {
+    applied: steps.length,
+    steps: steps.map((s) => s.type),
+    ...nodes.length || edges.length ? { created: { nodes, edges } } : {}
+  };
 }
 function createEditorMcpToolProvider(options) {
   const edit = (name) => async (args) => {
-    const steps = planToolCall(name, args, options.getSnapshot(), options.plannerOptions);
-    if (steps.length === 0) {
-      throw new Error(`Operation "${args.operation}" is missing required arguments.`);
+    const command = toolCallToAgentCommand(name, args);
+    if (!command) {
+      throw new Error(
+        name === "edit_canvas" || name === "edit_prompt" ? missingArgumentsMessage(name, args) : `Invalid arguments for "${name}".`
+      );
     }
+    const snapshot = options.getSnapshot();
+    const problem = validateAgentCommand(command, snapshot);
+    if (problem) throw new Error(problem);
+    const steps = planAgentCommand(command, snapshot, options.plannerOptions);
     await options.applySteps(steps);
-    return { applied: steps.length, steps: steps.map((s) => s.type) };
+    return describeSteps(steps);
   };
+  const canvas = _nullishCoalesce(_optionalChain([options, 'access', _18 => _18.surfaces, 'optionalAccess', _19 => _19.canvas]), () => ( true));
+  const prompt = _nullishCoalesce(_optionalChain([options, 'access', _20 => _20.surfaces, 'optionalAccess', _21 => _21.prompt]), () => ( true));
+  const editTools = options.toolStyle === "combined" ? [...canvas ? [_chunkK2LVZ4FAcjs.MCP_TOOL_EDIT_CANVAS] : [], ...prompt ? [_chunkK2LVZ4FAcjs.MCP_TOOL_EDIT_PROMPT] : []] : [...canvas ? _chunkK2LVZ4FAcjs.EDITOR_CANVAS_TOOLS : [], ...prompt ? _chunkK2LVZ4FAcjs.EDITOR_PROMPT_TOOLS : []];
   const tools = [
     {
-      ..._chunkV7CC7RZ6cjs.MCP_TOOL_GET_EDITOR_STATE,
+      ..._chunkK2LVZ4FAcjs.MCP_TOOL_GET_EDITOR_STATE,
       handler: ({ includeDocument = true, includeCanvas = true }) => {
         const snapshot = options.getSnapshot();
         return {
@@ -589,13 +1030,12 @@ function createEditorMcpToolProvider(options) {
         };
       }
     },
-    { ..._chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_CANVAS, handler: edit(_chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_CANVAS.name) },
-    { ..._chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_PROMPT, handler: edit(_chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_PROMPT.name) }
+    ...editTools.map((definition) => ({ ...definition, handler: edit(definition.name) }))
   ];
   if (options.captureView) {
     const capture = options.captureView;
     tools.push({
-      ..._chunkV7CC7RZ6cjs.MCP_TOOL_VIEW_EDITOR,
+      ..._chunkK2LVZ4FAcjs.MCP_TOOL_VIEW_EDITOR,
       handler: async (args) => {
         const image = await capture(args);
         return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }] };
@@ -608,8 +1048,33 @@ function createEditorMcpToolProvider(options) {
 // src/agent/componentTools.ts
 var IDS = { type: "array", items: { type: "string" }, description: "Node ids (default: the selection)." };
 var ID = { type: "string", description: "An instance, or a layer inside one (default: the first selected node)." };
+var COMPONENT_ID = { type: "string", description: "Component or component set id (from list_components)." };
+var PARENT_ID = { type: "string", description: "Frame to place the instance in (default: the canvas root)." };
+var X = { type: "number", description: "X position (canvas coordinates, or relative to the parent frame)." };
+var Y = { type: "number", description: "Y position (canvas coordinates, or relative to the parent frame)." };
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var TITLES = {
+  list_components: "List components",
+  inspect_instance: "Inspect an instance",
+  create_component: "Create a component",
+  combine_as_variants: "Combine as variants",
+  create_instance: "Create an instance",
+  set_instance_properties: "Set instance properties",
+  swap_instance: "Swap an instance",
+  reset_overrides: "Reset overrides",
+  push_overrides: "Push overrides to the main component",
+  detach_instance: "Detach instances",
+  go_to_main_component: "Go to the main component",
+  restore_main_component: "Restore the main component",
+  add_variant: "Add a variant",
+  remove_variant: "Remove a variant",
+  set_variant_properties: "Set variant properties",
+  rename_variant_property: "Rename a variant property",
+  rename_variant_value: "Rename a variant value"
+};
+var DESTRUCTIVE_TOOLS = /* @__PURE__ */ new Set(["reset_overrides", "push_overrides", "detach_instance", "remove_variant"]);
 var check = (result) => {
   if (!result.ok) throw new Error(result.reason);
   return { ids: result.ids };
@@ -617,9 +1082,13 @@ var check = (result) => {
 function createCanvasComponentToolProvider(controller, options = { id: "canvas-components" }) {
   const tool = (name, description, properties, handler, extra = {}) => ({
     name,
+    title: TITLES[name],
     description,
     inputSchema: { type: "object", properties, ...extra.required ? { required: extra.required } : {}, additionalProperties: false },
-    annotations: extra.readOnly ? READ : WRITE,
+    annotations: {
+      title: TITLES[name],
+      ...extra.readOnly ? READ : DESTRUCTIVE_TOOLS.has(name) ? DESTRUCTIVE : WRITE
+    },
     handler
   });
   const tools = [
@@ -653,10 +1122,10 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
       "create_instance",
       "Places an instance of a component or component set, optionally inside a frame, at a position, with property values.",
       {
-        componentId: { type: "string" },
-        parentId: { type: "string" },
-        x: { type: "number" },
-        y: { type: "number" },
+        componentId: COMPONENT_ID,
+        parentId: PARENT_ID,
+        x: X,
+        y: Y,
         properties: { type: "object", additionalProperties: true, description: "Variant and component property values." }
       },
       ({ componentId, parentId, x, y, properties }) => check(
@@ -671,21 +1140,28 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
     tool(
       "set_instance_properties",
       "Sets property values of instances: variant properties switch the variant (keeping compatible overrides), booleans toggle layers, text sets text, instance swap takes a component id.",
-      { properties: { type: "object", additionalProperties: true }, ids: IDS },
+      {
+        properties: {
+          type: "object",
+          additionalProperties: true,
+          description: "Property name \u2192 value (see inspect_instance for the names and types)."
+        },
+        ids: IDS
+      },
       ({ properties, ids }) => check(controller.setInstanceProperties(properties, ids)),
       { required: ["properties"] }
     ),
     tool(
       "swap_instance",
       "Makes instances show another component (or a set\u2019s default variant), keeping overrides of layers with matching names.",
-      { componentId: { type: "string" }, ids: IDS },
+      { componentId: COMPONENT_ID, ids: IDS },
       ({ componentId, ids }) => check(controller.swapInstance(componentId, ids)),
       { required: ["componentId"] }
     ),
     tool(
       "reset_overrides",
       'Resets overrides: of a whole instance (default), of one layer, or one override group such as "data.label" or "shape.fill".',
-      { id: ID, group: { type: "string" } },
+      { id: ID, group: { type: "string", description: 'Override group, e.g. "data.label" or "shape.fill" (default: all).' } },
       ({ id, group }) => check(controller.resetOverrides(id, group))
     ),
     tool(
@@ -715,7 +1191,7 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
       tool(
         "add_variant",
         'Adds a variant to a component set by duplicating one (default: the set\u2019s default variant) with new property values. Unnamed properties keep the source\u2019s values; new property names are added to every variant ("Default"). A combination another variant has is refused. Without values the next "VariantN" is used.',
-        { setId: SET, from: { type: "string", description: "Variant to duplicate." }, variant: VALUES, x: { type: "number" }, y: { type: "number" } },
+        { setId: SET, from: { type: "string", description: "Variant to duplicate." }, variant: VALUES, x: X, y: Y },
         ({ setId, from, variant, x, y }) => check(
           controller.addVariant(setId, {
             ...from !== void 0 ? { from } : {},
@@ -740,14 +1216,23 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
       tool(
         "rename_variant_property",
         "Renames a variant property across a component set (instances keep their variant).",
-        { name: { type: "string" }, newName: { type: "string" }, setId: SET },
+        {
+          name: { type: "string", description: "Current property name." },
+          newName: { type: "string", description: "New property name." },
+          setId: SET
+        },
         ({ name, newName, setId }) => check(controller.renameVariantProperty(name, newName, setId)),
         { required: ["name", "newName"] }
       ),
       tool(
         "rename_variant_value",
         "Renames a value of a variant property across a component set (instances keep their variant).",
-        { property: { type: "string" }, value: { type: "string" }, newValue: { type: "string" }, setId: SET },
+        {
+          property: { type: "string", description: "Variant property name." },
+          value: { type: "string", description: "Current value." },
+          newValue: { type: "string", description: "New value." },
+          setId: SET
+        },
         ({ property, value, newValue, setId }) => check(controller.renameVariantValue(property, value, newValue, setId)),
         { required: ["property", "value", "newValue"] }
       )
@@ -776,5 +1261,23 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
 
 
 
-exports.EDITOR_MCP_TOOLS = _chunkV7CC7RZ6cjs.EDITOR_MCP_TOOLS; exports.EXPORT_EXCLUDED_SELECTORS = _chunkV7CC7RZ6cjs.EXPORT_EXCLUDED_SELECTORS; exports.MCP_TOOL_EDIT_CANVAS = _chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = _chunkV7CC7RZ6cjs.MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = _chunkV7CC7RZ6cjs.MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_VIEW_EDITOR = _chunkV7CC7RZ6cjs.MCP_TOOL_VIEW_EDITOR; exports.TOOL_NAMESPACE_SEPARATOR = _chunkV7CC7RZ6cjs.TOOL_NAMESPACE_SEPARATOR; exports.ToolRegistry = _chunkV7CC7RZ6cjs.ToolRegistry; exports.ToolRegistryError = _chunkV7CC7RZ6cjs.ToolRegistryError; exports.createCanvasComponentToolProvider = createCanvasComponentToolProvider; exports.createEditorMcpToolProvider = createEditorMcpToolProvider; exports.createRichTextToolProvider = createRichTextToolProvider; exports.createSpreadsheetToolProvider = createSpreadsheetToolProvider; exports.createToolRegistry = _chunkV7CC7RZ6cjs.createToolRegistry; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand; exports.planToolCall = planToolCall; exports.toToolResult = _chunkV7CC7RZ6cjs.toToolResult; exports.toolCallToAgentCommand = toolCallToAgentCommand; exports.validateJsonSchema = _chunkI6BZB5ZHcjs.validateJsonSchema;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EDITOR_CANVAS_TOOLS = _chunkK2LVZ4FAcjs.EDITOR_CANVAS_TOOLS; exports.EDITOR_MCP_TOOLS = _chunkK2LVZ4FAcjs.EDITOR_MCP_TOOLS; exports.EDITOR_PROMPT_TOOLS = _chunkK2LVZ4FAcjs.EDITOR_PROMPT_TOOLS; exports.EDIT_OPERATION_REQUIRED_ARGUMENTS = _chunkK2LVZ4FAcjs.EDIT_OPERATION_REQUIRED_ARGUMENTS; exports.EXPORT_EXCLUDED_SELECTORS = _chunkK2LVZ4FAcjs.EXPORT_EXCLUDED_SELECTORS; exports.JSON_RPC_ERRORS = _chunkK2LVZ4FAcjs.JSON_RPC_ERRORS; exports.MCP_PROTOCOL_VERSIONS = _chunkK2LVZ4FAcjs.MCP_PROTOCOL_VERSIONS; exports.MCP_TOOL_CANVAS_ADD_NODE = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_ADD_NODE; exports.MCP_TOOL_CANVAS_CONNECT = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_CONNECT; exports.MCP_TOOL_CANVAS_HIGHLIGHT = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_HIGHLIGHT; exports.MCP_TOOL_CANVAS_LAYOUT = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_LAYOUT; exports.MCP_TOOL_CANVAS_REMOVE_NODES = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_REMOVE_NODES; exports.MCP_TOOL_CANVAS_SELECT = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_SELECT; exports.MCP_TOOL_CANVAS_UPDATE_NODE = _chunkK2LVZ4FAcjs.MCP_TOOL_CANVAS_UPDATE_NODE; exports.MCP_TOOL_EDIT_CANVAS = _chunkK2LVZ4FAcjs.MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = _chunkK2LVZ4FAcjs.MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = _chunkK2LVZ4FAcjs.MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_PROMPT_INSERT_TEXT = _chunkK2LVZ4FAcjs.MCP_TOOL_PROMPT_INSERT_TEXT; exports.MCP_TOOL_PROMPT_REPLACE_RANGE = _chunkK2LVZ4FAcjs.MCP_TOOL_PROMPT_REPLACE_RANGE; exports.MCP_TOOL_PROMPT_SELECT = _chunkK2LVZ4FAcjs.MCP_TOOL_PROMPT_SELECT; exports.MCP_TOOL_PROMPT_SET_VARIABLE = _chunkK2LVZ4FAcjs.MCP_TOOL_PROMPT_SET_VARIABLE; exports.MCP_TOOL_VIEW_EDITOR = _chunkK2LVZ4FAcjs.MCP_TOOL_VIEW_EDITOR; exports.TOOL_NAMESPACE_SEPARATOR = _chunkK2LVZ4FAcjs.TOOL_NAMESPACE_SEPARATOR; exports.ToolRegistry = _chunkK2LVZ4FAcjs.ToolRegistry; exports.ToolRegistryError = _chunkK2LVZ4FAcjs.ToolRegistryError; exports.createCanvasComponentToolProvider = createCanvasComponentToolProvider; exports.createEditorMcpToolProvider = createEditorMcpToolProvider; exports.createMcpServer = _chunkK2LVZ4FAcjs.createMcpServer; exports.createRichTextToolProvider = createRichTextToolProvider; exports.createSpreadsheetToolProvider = createSpreadsheetToolProvider; exports.createToolRegistry = _chunkK2LVZ4FAcjs.createToolRegistry; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand; exports.planToolCall = planToolCall; exports.toToolResult = _chunkK2LVZ4FAcjs.toToolResult; exports.toolCallToAgentCommand = toolCallToAgentCommand; exports.validateAgentCommand = validateAgentCommand; exports.validateJsonSchema = _chunkEFDCLENWcjs.validateJsonSchema;
 //# sourceMappingURL=index.cjs.map