@pixerate/editor 0.19.0 → 0.20.0

package/dist/agent/index.cjs

@@ -1,4 +1,14 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+var _chunkTVRC4KVTcjs = require('../chunk-TVRC4KVT.cjs');
+
+
+
+
+var _chunkJYRIOFENcjs = require('../chunk-JYRIOFEN.cjs');
+
 
 
 
@@ -203,11 +213,65 @@ function planAgentCommand(command, snapshot, options = {}) {
         }
       ];
     }
+    case "tool:call": {
+      return [
+        {
+          type: "step:tool_call",
+          name: command.name,
+          arguments: _nullishCoalesce(command.arguments, () => ( {}))
+        }
+      ];
+    }
     default: {
       return [];
     }
   }
 }
+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) {
+      case "add_node":
+        return args.node && typeof args.node === "object" ? { type: "canvas:add_node", node: args.node, 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;
+      }
+      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;
+      default:
+        return null;
+    }
+  }
+  if (name === "edit_prompt") {
+    switch (args.operation) {
+      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":
+        return typeof args.text === "string" && num(args.from) && num(args.to) ? { type: "prompt:replace_range", from: args.from, to: args.to, text: args.text } : null;
+      case "set_variable":
+        return typeof args.name === "string" ? { type: "prompt:set_variable", name: args.name, value: args.value } : null;
+      case "select":
+        return num(args.from) && num(args.to) ? { type: "prompt:select", from: args.from, to: args.to } : null;
+      default:
+        return null;
+    }
+  }
+  return { type: "tool:call", name, arguments: args };
+}
+function planToolCall(name, args, snapshot, options) {
+  const command = toolCallToAgentCommand(name, args);
+  return command ? planAgentCommand(command, snapshot, options) : [];
+}
 
 // src/agent/tools.ts
 var MCP_TOOL_GET_EDITOR_STATE = {
@@ -362,6 +426,565 @@ var EDITOR_MCP_TOOLS = [
   MCP_TOOL_VIEW_EDITOR
 ];
 
+// src/agent/schema.ts
+function typeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "number";
+  if (typeof value === "string" || typeof value === "boolean" || typeof value === "object") {
+    return typeof value;
+  }
+  return "undefined";
+}
+function matchesType(value, type) {
+  const actual = typeOf(value);
+  if (type === "number") return actual === "number" || actual === "integer";
+  return actual === type;
+}
+var isEqual = (a, b) => a === b || JSON.stringify(a) === JSON.stringify(b);
+function validateJsonSchema(value, schema, path = "") {
+  if (!schema || typeof schema !== "object") return [];
+  const errors = [];
+  const at = path || "/";
+  if (schema.type !== void 0) {
+    const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (!types.some((t) => matchesType(value, t))) {
+      errors.push({ path: at, message: `Expected ${types.join(" | ")}, got ${typeOf(value)}.` });
+      return errors;
+    }
+  }
+  if (schema.const !== void 0 && !isEqual(value, schema.const)) {
+    errors.push({ path: at, message: `Expected ${JSON.stringify(schema.const)}.` });
+  }
+  if (schema.enum && !schema.enum.some((option) => isEqual(value, option))) {
+    errors.push({
+      path: at,
+      message: `Expected one of ${schema.enum.map((o) => JSON.stringify(o)).join(", ")}, got ${JSON.stringify(value)}.`
+    });
+  }
+  if (typeof value === "string") {
+    if (schema.minLength !== void 0 && value.length < schema.minLength) {
+      errors.push({ path: at, message: `Must be at least ${schema.minLength} characters.` });
+    }
+    if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+      errors.push({ path: at, message: `Must be at most ${schema.maxLength} characters.` });
+    }
+    if (schema.pattern !== void 0) {
+      let regex = null;
+      try {
+        regex = new RegExp(schema.pattern, "u");
+      } catch (e2) {
+      }
+      if (regex && !regex.test(value)) {
+        errors.push({ path: at, message: `Must match pattern ${schema.pattern}.` });
+      }
+    }
+  }
+  if (typeof value === "number") {
+    if (schema.minimum !== void 0 && value < schema.minimum) {
+      errors.push({ path: at, message: `Must be >= ${schema.minimum}.` });
+    }
+    if (schema.maximum !== void 0 && value > schema.maximum) {
+      errors.push({ path: at, message: `Must be <= ${schema.maximum}.` });
+    }
+  }
+  if (Array.isArray(value)) {
+    if (schema.minItems !== void 0 && value.length < schema.minItems) {
+      errors.push({ path: at, message: `Must have at least ${schema.minItems} items.` });
+    }
+    if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+      errors.push({ path: at, message: `Must have at most ${schema.maxItems} items.` });
+    }
+    if (schema.items) {
+      value.forEach((item, index) => {
+        errors.push(...validateJsonSchema(item, schema.items, `${path}/${index}`));
+      });
+    }
+  }
+  if (typeOf(value) === "object") {
+    const obj = value;
+    for (const key of _nullishCoalesce(schema.required, () => ( []))) {
+      if (obj[key] === void 0) {
+        errors.push({ path: `${path}/${key}`, message: `Missing required property "${key}".` });
+      }
+    }
+    const properties = _nullishCoalesce(schema.properties, () => ( {}));
+    for (const [key, child] of Object.entries(obj)) {
+      if (child === void 0) continue;
+      if (key in properties) {
+        errors.push(...validateJsonSchema(child, properties[key], `${path}/${key}`));
+      } else if (schema.additionalProperties === false) {
+        errors.push({ path: `${path}/${key}`, message: `Unknown property "${key}".` });
+      } else if (typeof schema.additionalProperties === "object") {
+        errors.push(...validateJsonSchema(child, schema.additionalProperties, `${path}/${key}`));
+      }
+    }
+  }
+  return errors;
+}
+
+// src/agent/registry.ts
+var ToolRegistryError = class extends Error {
+  
+  constructor(code, message) {
+    super(message);
+    this.name = "ToolRegistryError";
+    this.code = code;
+  }
+};
+var TOOL_NAMESPACE_SEPARATOR = "__";
+var TOOL_NAME_REGEX = /^[A-Za-z0-9_.-]{1,128}$/;
+var sanitizeNamespace = (id) => id.replace(/[^A-Za-z0-9_-]/g, "_");
+function readTools(provider) {
+  return typeof provider.tools === "function" ? provider.tools() : provider.tools;
+}
+function toDefinition(name, tool) {
+  const { handler: _handler, name: _name, ...rest } = tool;
+  return { name, ...rest };
+}
+function errorResult(error) {
+  const details = _optionalChain([error, 'access', _13 => _13.details, 'optionalAccess', _14 => _14.length]) ? "\n" + error.details.map((d) => `- ${d.path}: ${d.message}`).join("\n") : "";
+  return {
+    isError: true,
+    content: [{ type: "text", text: `${error.message}${details}` }],
+    structuredContent: { error }
+  };
+}
+function toToolResult(value) {
+  if (value && typeof value === "object" && Array.isArray(value.content)) {
+    return value;
+  }
+  if (value === void 0) return { content: [] };
+  if (typeof value === "string") return { content: [{ type: "text", text: value }] };
+  const text = JSON.stringify(value);
+  const isPlainObject = typeof value === "object" && value !== null && !Array.isArray(value);
+  return {
+    content: [{ type: "text", text: _nullishCoalesce(text, () => ( String(value))) }],
+    ...isPlainObject ? { structuredContent: value } : {}
+  };
+}
+var ToolRegistry = (_class = class {
+  /** MCP server capabilities this registry supports. */
+  __init() {this.capabilities = { tools: { listChanged: true } }}
+  __init2() {this.entries = []}
+  __init3() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  __init4() {this.timer = null}
+  
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.options = {
+      onCollision: _nullishCoalesce(options.onCollision, () => ( "namespace")),
+      listChangedDelayMs: _nullishCoalesce(options.listChangedDelayMs, () => ( 0)),
+      validateArguments: _nullishCoalesce(options.validateArguments, () => ( true))
+    };
+    this.lastSignature = this.signature();
+  }
+  /**
+   * Registers a provider and returns a function that unregisters it.
+   * Throws a {@link ToolRegistryError} for a duplicate provider id, an invalid
+   * tool name, or (with `onCollision: 'error'`) a tool name collision.
+   */
+  register(provider) {
+    if (this.entries.some((e) => e.provider.id === provider.id)) {
+      throw new ToolRegistryError("duplicate_provider", `Tool provider "${provider.id}" is already registered.`);
+    }
+    for (const tool of readTools(provider)) {
+      if (!TOOL_NAME_REGEX.test(tool.name)) {
+        throw new ToolRegistryError("invalid_tool", `Invalid tool name "${tool.name}" from provider "${provider.id}".`);
+      }
+    }
+    const entry = { provider };
+    this.entries.push(entry);
+    try {
+      const names = this.resolve(this.options.onCollision === "error").map((t) => t.name);
+      const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+      if (duplicate) {
+        throw new ToolRegistryError("name_collision", `Tool name "${duplicate}" is exposed more than once.`);
+      }
+    } catch (error) {
+      this.entries.pop();
+      throw error;
+    }
+    if (provider.subscribe) {
+      entry.unsubscribe = provider.subscribe(() => this.notifyListChanged());
+    }
+    this.notifyListChanged();
+    let registered = true;
+    return () => {
+      if (!registered) return;
+      registered = false;
+      this.unregister(provider);
+    };
+  }
+  /** Removes a provider by id or instance. Returns whether it was registered. */
+  unregister(providerOrId) {
+    const index = this.entries.findIndex(
+      (e) => typeof providerOrId === "string" ? e.provider.id === providerOrId : e.provider === providerOrId
+    );
+    if (index === -1) return false;
+    const [entry] = this.entries.splice(index, 1);
+    _optionalChain([entry, 'access', _15 => _15.unsubscribe, 'optionalCall', _16 => _16()]);
+    this.notifyListChanged();
+    return true;
+  }
+  /** Registered provider ids in registration order. */
+  providerIds() {
+    return this.entries.map((e) => e.provider.id);
+  }
+  /**
+   * Resolves exposed names. Tools are ordered by provider registration, then
+   * by their order within the provider.
+   */
+  resolve(throwOnCollision = false) {
+    const all = [];
+    const counts = /* @__PURE__ */ new Map();
+    for (const { provider } of this.entries) {
+      for (const tool of readTools(provider)) {
+        all.push({ name: tool.name, tool, provider });
+        if (!provider.namespace) counts.set(tool.name, (_nullishCoalesce(counts.get(tool.name), () => ( 0))) + 1);
+      }
+    }
+    for (const item of all) {
+      const prefix = _nullishCoalesce(item.provider.namespace, () => ( ((_nullishCoalesce(counts.get(item.name), () => ( 0))) > 1 ? item.provider.id : void 0)));
+      if (prefix !== void 0) {
+        if (throwOnCollision && !item.provider.namespace) {
+          throw new ToolRegistryError(
+            "name_collision",
+            `Tool "${item.name}" from provider "${item.provider.id}" collides with another provider's tool.`
+          );
+        }
+        item.name = `${sanitizeNamespace(prefix)}${TOOL_NAMESPACE_SEPARATOR}${item.name}`;
+      }
+    }
+    return all;
+  }
+  /** MCP `tools/list` result for the current providers. */
+  listTools() {
+    return { tools: this.resolve().map(({ name, tool }) => toDefinition(name, tool)) };
+  }
+  /** Whether a tool with this exposed name exists. */
+  hasTool(name) {
+    return this.resolve().some((t) => t.name === name);
+  }
+  /** Looks up a tool definition by exposed name. */
+  getTool(name) {
+    const found = this.resolve().find((t) => t.name === name);
+    return found ? toDefinition(found.name, found.tool) : void 0;
+  }
+  /**
+   * Calls a tool by exposed name and returns an MCP `tools/call` result.
+   * Never rejects: unknown tools, invalid arguments and handler errors come
+   * back as `isError: true` results with a {@link ToolCallError} in
+   * `structuredContent.error` (MCP transports may map `unknown_tool` to a
+   * JSON-RPC `-32602` error instead).
+   */
+  async callTool(name, args = {}, options = {}) {
+    const found = this.resolve().find((t) => t.name === name);
+    if (!found) {
+      return errorResult({ code: "unknown_tool", message: `Unknown tool "${name}".`, tool: name });
+    }
+    const input = _nullishCoalesce(args, () => ( {}));
+    if (this.options.validateArguments) {
+      const details = validateJsonSchema(input, found.tool.inputSchema);
+      if (details.length > 0) {
+        return errorResult({
+          code: "invalid_arguments",
+          message: `Invalid arguments for tool "${name}".`,
+          tool: name,
+          details
+        });
+      }
+    }
+    try {
+      const value = await found.tool.handler(input, {
+        name,
+        providerId: found.provider.id,
+        signal: options.signal
+      });
+      return toToolResult(value);
+    } catch (error) {
+      return errorResult({
+        code: "tool_failed",
+        message: error instanceof Error ? error.message : String(error),
+        tool: name
+      });
+    }
+  }
+  /**
+   * Subscribes to tool-list changes. Notifications are coalesced: many
+   * registrations or provider signals within the delay window produce one
+   * call, and none if the exposed list ends up unchanged (e.g. a provider
+   * unmounted and remounted). Returns an unsubscribe function.
+   */
+  onListChanged(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Schedules a coalesced `listChanged` check; providers may call it directly. */
+  notifyListChanged() {
+    if (this.timer !== null) return;
+    this.timer = setTimeout(() => this.flush(), this.options.listChangedDelayMs);
+  }
+  /** Runs a pending `listChanged` check immediately. */
+  flush() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const signature = this.signature();
+    if (signature === this.lastSignature) return;
+    this.lastSignature = signature;
+    const { tools } = this.listTools();
+    for (const listener of Array.from(this.listeners)) listener(tools);
+  }
+  signature() {
+    try {
+      return JSON.stringify(this.listTools().tools);
+    } catch (e3) {
+      return String(Math.random());
+    }
+  }
+  /** Unregisters every provider and listener and cancels pending notifications. */
+  dispose() {
+    if (this.timer !== null) clearTimeout(this.timer);
+    this.timer = null;
+    for (const entry of this.entries.splice(0)) _optionalChain([entry, 'access', _17 => _17.unsubscribe, 'optionalCall', _18 => _18()]);
+    this.listeners.clear();
+  }
+}, _class);
+function createToolRegistry(options) {
+  return new ToolRegistry(options);
+}
+
+// src/agent/providers.ts
+var toEditor = (target) => "commands" in target ? target : target.editor;
+function replaceWithText(editor, from, to, text) {
+  const { state, view } = editor;
+  const tr = /[\r\n]/.test(text) ? state.tr.replace(from, to, _chunkTVRC4KVTcjs.plainTextToSlice.call(void 0, text, state.schema)) : text ? state.tr.insertText(text, from, to) : state.tr.delete(from, to);
+  view.dispatch(tr.scrollIntoView());
+}
+function selectionInfo(editor) {
+  const { from, to } = editor.state.selection;
+  return { from, to, text: editor.state.doc.textBetween(from, to, "\n") };
+}
+function createRichTextToolProvider(target, options) {
+  const editor = () => toEditor(target);
+  const getText = {
+    name: "get_text",
+    description: "Returns the document content (plain text by default, or HTML / markdown) and the current selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        format: {
+          type: "string",
+          enum: ["text", "html", "markdown"],
+          description: "Content format (default: text)."
+        }
+      },
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true },
+    handler: ({ format = "text" }) => {
+      const ed = editor();
+      const content = format === "html" ? ed.getHTML() : format === "markdown" ? _chunkTVRC4KVTcjs.getEditorMarkdown.call(void 0, ed) : _chunkTVRC4KVTcjs.getEditorText.call(void 0, ed);
+      return { format, content, selection: selectionInfo(ed), size: ed.state.doc.content.size };
+    }
+  };
+  const insertText = {
+    name: "insert_text",
+    description: "Inserts literal text (newlines start new paragraphs) at a document position, or at the cursor when `at` is omitted.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to insert." },
+        at: { type: "integer", minimum: 0, description: "Document position (default: the selection)." }
+      },
+      required: ["text"],
+      additionalProperties: false
+    },
+    handler: ({ text, at }) => {
+      const ed = editor();
+      const size = ed.state.doc.content.size;
+      if (at !== void 0 && at > size) {
+        throw new Error(`Position ${at} is outside the document (size ${size}).`);
+      }
+      const { from, to } = ed.state.selection;
+      replaceWithText(ed, _nullishCoalesce(at, () => ( from)), _nullishCoalesce(at, () => ( to)), text);
+      return { inserted: text.length, selection: selectionInfo(ed) };
+    }
+  };
+  const replaceSelection = {
+    name: "replace_selection",
+    description: "Replaces the selected content with literal text (an empty string deletes the selection).",
+    inputSchema: {
+      type: "object",
+      properties: { text: { type: "string", description: "Replacement text." } },
+      required: ["text"],
+      additionalProperties: false
+    },
+    annotations: { destructiveHint: true },
+    handler: ({ text }) => {
+      const ed = editor();
+      const { from, to } = ed.state.selection;
+      replaceWithText(ed, from, to, text);
+      return { replaced: { from, to }, selection: selectionInfo(ed) };
+    }
+  };
+  return {
+    id: options.id,
+    namespace: options.namespace,
+    tools: () => {
+      const ed = editor();
+      if (!ed || ed.isDestroyed) return [];
+      return ed.isEditable ? [getText, insertText, replaceSelection] : [getText];
+    },
+    subscribe: (notify) => {
+      const ed = editor();
+      ed.on("update", notify);
+      ed.on("destroy", notify);
+      return () => {
+        ed.off("update", notify);
+        ed.off("destroy", notify);
+      };
+    }
+  };
+}
+var CELL_REF_REGEX = /^\$?([A-Za-z]{1,3})\$?(\d{1,7})$/;
+function parseCell(ref) {
+  const match = CELL_REF_REGEX.exec(ref.trim());
+  if (!match) throw new Error(`Invalid cell reference "${ref}". Use A1 notation, e.g. "B3".`);
+  return { col: _chunkJYRIOFENcjs.colNameToIndex.call(void 0, match[1].toUpperCase()), row: parseInt(match[2], 10) - 1 };
+}
+function createSpreadsheetToolProvider(controller, options) {
+  const lookup = (row, col) => {
+    const rowDef = controller.document.rows[row];
+    const colDef = controller.document.columns[col];
+    return rowDef && colDef ? { rowDef, colDef } : null;
+  };
+  const getRange = {
+    name: "get_range",
+    description: 'Reads a cell range in A1 notation (e.g. "A1:C5" or "B2") and returns computed values, raw input and errors.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        range: { type: "string", description: "A1-notation cell or range." }
+      },
+      required: ["range"],
+      additionalProperties: false
+    },
+    annotations: { readOnlyHint: true },
+    handler: ({ range }) => {
+      const [startRef, endRef = startRef] = String(range).split(":");
+      const start = parseCell(startRef);
+      const end = parseCell(endRef);
+      const rowCount = controller.document.rows.length;
+      const colCount = controller.document.columns.length;
+      const r0 = Math.min(start.row, end.row);
+      const r1 = Math.min(Math.max(start.row, end.row), rowCount - 1);
+      const c0 = Math.min(start.col, end.col);
+      const c1 = Math.min(Math.max(start.col, end.col), colCount - 1);
+      const values = [];
+      const raw = [];
+      const errors = [];
+      for (let r = r0; r <= r1; r++) {
+        const valueRow = [];
+        const rawRow = [];
+        for (let c = c0; c <= c1; c++) {
+          const found = lookup(r, c);
+          const cell = controller.getCell(found.rowDef.id, found.colDef.id);
+          valueRow.push(_nullishCoalesce(cell.error, () => ( cell.value)));
+          rawRow.push(cell.raw);
+          const error = _nullishCoalesce(cell.error, () => ( (_chunkJYRIOFENcjs.isFormulaError.call(void 0, cell.value) ? cell.value : void 0)));
+          if (error) errors.push({ cell: `${_chunkJYRIOFENcjs.indexToColName.call(void 0, c)}${r + 1}`, error });
+        }
+        values.push(valueRow);
+        raw.push(rawRow);
+      }
+      return {
+        range: values.length && values[0].length ? `${_chunkJYRIOFENcjs.indexToColName.call(void 0, c0)}${r0 + 1}:${_chunkJYRIOFENcjs.indexToColName.call(void 0, c1)}${r1 + 1}` : null,
+        values,
+        raw,
+        errors,
+        sheet: { rows: rowCount, columns: colCount }
+      };
+    }
+  };
+  const setCell = {
+    name: "set_cell",
+    description: 'Sets the raw input of one cell (A1 notation). Values starting with "=" are formulas.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        cell: { type: "string", description: 'A1-notation cell, e.g. "B3".' },
+        value: { type: ["string", "number", "boolean"], description: "Raw cell input." }
+      },
+      required: ["cell", "value"],
+      additionalProperties: false
+    },
+    handler: ({ cell, value }) => {
+      const { row, col } = parseCell(cell);
+      const found = lookup(row, col);
+      if (!found) throw new Error(`Cell ${cell} is outside the sheet.`);
+      const { rowDef, colDef } = found;
+      if (colDef.readOnly || controller.getCell(rowDef.id, colDef.id).readOnly || colDef.type === "formula") {
+        throw new Error(`Cell ${cell} is read-only.`);
+      }
+      controller.setCellValue(rowDef.id, colDef.id, String(value));
+      const updated = controller.getCell(rowDef.id, colDef.id);
+      return { cell: cell.toUpperCase(), raw: updated.raw, value: _nullishCoalesce(updated.error, () => ( updated.value)) };
+    }
+  };
+  return { id: options.id, namespace: options.namespace, tools: [getRange, setCell] };
+}
+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.`);
+    }
+    await options.applySteps(steps);
+    return { applied: steps.length, steps: steps.map((s) => s.type) };
+  };
+  const tools = [
+    {
+      ...MCP_TOOL_GET_EDITOR_STATE,
+      handler: ({ includeDocument = true, includeCanvas = true }) => {
+        const snapshot = options.getSnapshot();
+        return {
+          ...includeDocument && snapshot.document ? { document: snapshot.document } : {},
+          ...includeCanvas && snapshot.canvas ? { canvas: snapshot.canvas } : {}
+        };
+      }
+    },
+    { ...MCP_TOOL_EDIT_CANVAS, handler: edit(MCP_TOOL_EDIT_CANVAS.name) },
+    { ...MCP_TOOL_EDIT_PROMPT, handler: edit(MCP_TOOL_EDIT_PROMPT.name) }
+  ];
+  if (options.captureView) {
+    const capture = options.captureView;
+    tools.push({
+      ...MCP_TOOL_VIEW_EDITOR,
+      handler: async (args) => {
+        const image = await capture(args);
+        return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }] };
+      }
+    });
+  }
+  return { id: options.id, namespace: options.namespace, tools };
+}
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -370,5 +993,5 @@ var EDITOR_MCP_TOOLS = [
 
 
 
-exports.EDITOR_MCP_TOOLS = EDITOR_MCP_TOOLS; exports.EXPORT_EXCLUDED_SELECTORS = EXPORT_EXCLUDED_SELECTORS; exports.MCP_TOOL_EDIT_CANVAS = MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_VIEW_EDITOR = MCP_TOOL_VIEW_EDITOR; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand;
+exports.EDITOR_MCP_TOOLS = EDITOR_MCP_TOOLS; exports.EXPORT_EXCLUDED_SELECTORS = EXPORT_EXCLUDED_SELECTORS; exports.MCP_TOOL_EDIT_CANVAS = MCP_TOOL_EDIT_CANVAS; exports.MCP_TOOL_EDIT_PROMPT = MCP_TOOL_EDIT_PROMPT; exports.MCP_TOOL_GET_EDITOR_STATE = MCP_TOOL_GET_EDITOR_STATE; exports.MCP_TOOL_VIEW_EDITOR = MCP_TOOL_VIEW_EDITOR; exports.TOOL_NAMESPACE_SEPARATOR = TOOL_NAMESPACE_SEPARATOR; exports.ToolRegistry = ToolRegistry; exports.ToolRegistryError = ToolRegistryError; exports.createEditorMcpToolProvider = createEditorMcpToolProvider; exports.createRichTextToolProvider = createRichTextToolProvider; exports.createSpreadsheetToolProvider = createSpreadsheetToolProvider; exports.createToolRegistry = createToolRegistry; exports.normalizeSide = normalizeSide; exports.planAgentCommand = planAgentCommand; exports.planToolCall = planToolCall; exports.toToolResult = toToolResult; exports.toolCallToAgentCommand = toolCallToAgentCommand; exports.validateJsonSchema = validateJsonSchema;
 //# sourceMappingURL=index.cjs.map