@pixerate/editor 0.139.1 → 0.140.1

package/dist/agent/index.js

@@ -12,20 +12,33 @@ import {
   placeBeside
 } from "../chunk-BTZS3KZY.js";
 import "../chunk-7KZ2HKKC.js";
-import "../chunk-SMJK5HBJ.js";
+import "../chunk-K73HMKQP.js";
 import {
   JSON_RPC_ERRORS,
   MCP_PROTOCOL_VERSIONS,
   TOOL_BRIDGE_DEFAULT_PORT,
   TOOL_BRIDGE_PROTOCOL,
+  TOOL_DISCOVERY_TOOLS,
   TOOL_NAMESPACE_SEPARATOR,
   ToolRegistry,
   ToolRegistryError,
+  ToolRegistryView,
+  baseToolName,
   connectToolBridge,
   createMcpServer,
   createToolRegistry,
-  toToolResult
-} from "../chunk-5RRYDFU2.js";
+  errorResult,
+  listSkills,
+  parseSkillFrontmatter,
+  readSkillFile,
+  searchTokens,
+  searchTools,
+  summarize,
+  toToolResult,
+  toolsetInstructions,
+  toolsetName,
+  unknownToolMessage
+} from "../chunk-RB62U6MS.js";
 import {
   CAPTURE_EXCLUDE_SELECTOR,
   CAPTURE_OVERLAY_SELECTORS,
@@ -53,7 +66,7 @@ import {
   createElementCaptureSurface,
   elementToSvg,
   rasterizeElement
-} from "../chunk-TBSPPVTT.js";
+} from "../chunk-XCK7QK5D.js";
 import {
   captureInputSchema,
   captureOutputSize,
@@ -62,7 +75,7 @@ import {
   resolveCaptureRequest,
   toCapturedImageData,
   unionCaptureRects
-} from "../chunk-BKMU3V6K.js";
+} from "../chunk-5ED73EC6.js";
 import {
   DEFAULT_AGENT_CARET_COLOR,
   DEFAULT_AGENT_CARET_NAME,
@@ -83,7 +96,7 @@ import {
   setAgentCaret,
   sparklineLabel,
   typeAgentText
-} from "../chunk-VRIR53SW.js";
+} from "../chunk-6GAYGQDC.js";
 import {
   describeChart
 } from "../chunk-KI2VBONS.js";
@@ -95,9 +108,14 @@ import {
 import {
   getEditorMarkdown,
   getEditorText
-} from "../chunk-SWZTQWY7.js";
+} from "../chunk-2INPJDNY.js";
 import "../chunk-RTRQ7XFI.js";
-import "../chunk-HZZXBTLB.js";
+import "../chunk-6IN474P4.js";
+import {
+  UNSAFE_JSON_KEYS,
+  isUnsafeJsonKey,
+  stripPrototypeKeys
+} from "../chunk-HF5QZS7Z.js";
 import {
   isSingleCellRange,
   normalizeRange,
@@ -438,7 +456,8 @@ function planToolCall(name, args, snapshot, options) {
 }
 
 // src/agent/providers.ts
-import { TextSelection } from "@tiptap/pm/state";
+import { TextSelection as TextSelection2 } from "@tiptap/pm/state";
+import { closeHistory as closeHistory3 } from "@tiptap/pm/history";
 
 // src/agent/documentChartTools.ts
 import { closeHistory } from "@tiptap/pm/history";
@@ -636,6 +655,309 @@ function createDocumentChartTools(editor) {
   };
 }
 
+// src/agent/formatTools.ts
+import { closeHistory as closeHistory2 } from "@tiptap/pm/history";
+import { TextSelection } from "@tiptap/pm/state";
+var WRITE_IDEMPOTENT2 = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var TOGGLE_MARKS = [
+  ["bold", "bold", "Bold (strong) text."],
+  ["italic", "italic", "Italic (emphasis)."],
+  ["underline", "underline", "Underlined text."],
+  ["strike", "strike", "Struck-through text."],
+  ["code", "code", "Inline code (monospace; in most schemas it removes the other marks)."],
+  ["subscript", "subscript", "Subscript."],
+  ["superscript", "superscript", "Superscript."]
+];
+var BLOCK_TYPES = [
+  ["paragraph", "paragraph", "a plain paragraph (also takes the blocks out of lists, quotes and code blocks)"],
+  ["heading", "heading", "a heading of `level`"],
+  ["bullet_list", "bulletList", "items of a bulleted list"],
+  ["ordered_list", "orderedList", "items of a numbered list"],
+  ["task_list", "taskList", "items of a checklist"],
+  ["blockquote", "blockquote", "a quote"],
+  ["code_block", "codeBlock", "a code block (plain text: marks are dropped)"]
+];
+var LIST_ITEMS = { bulletList: "listItem", orderedList: "listItem", taskList: "taskItem" };
+var UNSAFE_LINK = /^\s*(javascript|data|vbscript):/i;
+var RANGE_PROPERTIES = {
+  from: { type: "integer", minimum: 0, description: "Start document position (from find_text or get_text `blocks`). Default: the selection." },
+  to: { type: "integer", minimum: 0, description: "End document position. Default: the selection." }
+};
+function targetRange(editor, args, allowEmpty) {
+  if (args.from === void 0 !== (args.to === void 0)) throw new Error('Pass both "from" and "to", or neither to use the selection.');
+  const { from, to } = args.from === void 0 ? editor.state.selection : { from: args.from, to: args.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}).`);
+  if (!allowEmpty && from === to) {
+    throw new Error('The range is empty: pass "from" and "to" around the text (find_text returns them), or select it first.');
+  }
+  return { from, to };
+}
+function checkEditable(editor) {
+  if (!editor.isEditable) throw new Error("The document is read-only, so it cannot be formatted.");
+}
+function selectionGuard(editor, range) {
+  const before = editor.state.selection;
+  return {
+    select: ({ tr }) => {
+      closeHistory2(tr);
+      tr.setSelection(TextSelection.between(tr.doc.resolve(range.from), tr.doc.resolve(range.to)));
+      return true;
+    },
+    restore: ({ tr }) => {
+      const anchor = tr.mapping.map(before.anchor);
+      const head = tr.mapping.map(before.head);
+      tr.setSelection(TextSelection.between(tr.doc.resolve(anchor), tr.doc.resolve(head)));
+      return true;
+    },
+    /** The acted-on range in the changed document. */
+    mapped: (tr) => ({ from: tr.mapping.map(range.from, -1), to: tr.mapping.map(range.to, 1) })
+  };
+}
+function blocksIn(doc, from, to) {
+  const blocks = [];
+  doc.nodesBetween(from, Math.max(to, from + 1), (node, pos, parent) => {
+    if (!node.isTextblock) return true;
+    const $pos = doc.resolve(pos + 1);
+    let wrapper;
+    for (let d = $pos.depth - 1; d > 0; d--) {
+      const name = $pos.node(d).type.name;
+      if (name === "bulletList" || name === "orderedList" || name === "taskList" || name === "blockquote") {
+        wrapper = name;
+        break;
+      }
+    }
+    blocks.push({
+      type: node.type.name,
+      from: pos + 1,
+      to: pos + 1 + node.content.size,
+      text: node.textContent,
+      ...node.attrs.level !== void 0 ? { level: node.attrs.level } : {},
+      ...node.attrs.textAlign ? { align: node.attrs.textAlign } : {},
+      ...wrapper ? { in: wrapper } : {},
+      ...parent && parent.type.name === "taskItem" ? { checked: !!parent.attrs.checked } : {}
+    });
+    return false;
+  });
+  return blocks;
+}
+function marksOn(doc, schema, from, to) {
+  const out = {};
+  for (const [arg, mark] of TOGGLE_MARKS) {
+    const type = schema.marks[mark];
+    if (!type) continue;
+    let all = true;
+    let any = false;
+    doc.nodesBetween(from, to, (node) => {
+      if (!node.isText) return true;
+      if (type.isInSet(node.marks)) any = true;
+      else all = false;
+      return false;
+    });
+    if (any) out[arg] = all ? true : "partly";
+  }
+  const attrOf = (markName, attr) => {
+    const values = /* @__PURE__ */ new Set();
+    doc.nodesBetween(from, to, (node) => {
+      if (!node.isText) return true;
+      const mark = node.marks.find((m) => m.type.name === markName);
+      values.add(mark ? mark.attrs[attr] ?? null : null);
+      return false;
+    });
+    const [only] = values;
+    return values.size === 1 ? only : values.size > 1 ? "mixed" : null;
+  };
+  if (schema.marks.link) {
+    const href = attrOf("link", "href");
+    if (href !== null) out.link = href;
+  }
+  if (schema.marks.highlight) {
+    const color = attrOf("highlight", "color");
+    if (color !== null) out.highlight = color;
+  }
+  if (schema.marks.textStyle) {
+    const color = attrOf("textStyle", "color");
+    if (color !== null) out.color = color;
+    const size = attrOf("textStyle", "fontSize");
+    if (size !== null) out.fontSize = size;
+  }
+  return out;
+}
+function createDocumentFormatTools(editor, changed) {
+  const formatText = (ed) => {
+    const { schema } = ed;
+    const has = (name) => !!schema.marks[name];
+    const hasAttr = (mark, attr) => !!schema.marks[mark]?.spec.attrs?.[attr];
+    const properties = { ...RANGE_PROPERTIES };
+    for (const [arg, mark, what] of TOGGLE_MARKS) {
+      if (has(mark)) properties[arg] = { type: "boolean", description: `${what} true sets it, false clears it; omit to leave it.` };
+    }
+    if (has("link")) {
+      properties.link = {
+        type: ["string", "null"],
+        minLength: 1,
+        description: "Link the text to this URL (https://\u2026, mailto:\u2026), or null to remove links. Omit to leave links."
+      };
+    }
+    if (has("highlight")) {
+      properties.highlight = {
+        type: ["string", "null"],
+        minLength: 1,
+        maxLength: 64,
+        description: 'Highlight (background) colour as a CSS colour, e.g. "#fef08a" or "yellow", or null to remove it.'
+      };
+    }
+    if (hasAttr("textStyle", "color")) {
+      properties.color = { type: ["string", "null"], minLength: 1, maxLength: 64, description: "Text colour as a CSS colour, or null for the default colour." };
+    }
+    if (hasAttr("textStyle", "fontSize")) {
+      properties.fontSize = { type: ["string", "null"], pattern: "^\\d+(\\.\\d+)?(px|pt|em|rem|%)$", description: 'Font size with a unit, e.g. "18px" or "1.25em", or null for the default size.' };
+    }
+    const formatting = Object.keys(properties).filter((k) => k !== "from" && k !== "to");
+    if (formatting.length === 0) return null;
+    return {
+      name: "format_text",
+      title: "Format text",
+      description: `Sets or clears inline formatting on a range of text (or the selection): ${formatting.join(", ")}. Only the properties you pass change. Positions come from find_text or get_text \`blocks\`. One undo step; the selection is left where it was. Returns the \`range\` and the formatting now on it (\`partly\` / \`mixed\` where only some of the text has it). For headings and lists use set_block_type.`,
+      inputSchema: { type: "object", properties, additionalProperties: false },
+      annotations: { title: "Format text", ...WRITE_IDEMPOTENT2 },
+      handler: (args) => {
+        const ed2 = editor();
+        checkEditable(ed2);
+        const asked = formatting.filter((k) => args[k] !== void 0);
+        if (asked.length === 0) throw new Error(`Pass at least one formatting property: ${formatting.join(", ")}.`);
+        const range = targetRange(ed2, args, false);
+        if (typeof args.link === "string" && UNSAFE_LINK.test(args.link)) {
+          throw new Error("Links may not use javascript:, data: or vbscript: URLs. Nothing was changed.");
+        }
+        const guard = selectionGuard(ed2, range);
+        let tr = null;
+        let chain = ed2.chain().command(guard.select);
+        for (const [arg, mark] of TOGGLE_MARKS) {
+          if (args[arg] === true) chain = chain.setMark(mark);
+          else if (args[arg] === false) chain = chain.unsetMark(mark, { extendEmptyMarkRange: false });
+        }
+        if (args.link === null) chain = chain.unsetMark("link");
+        else if (typeof args.link === "string") chain = chain.setMark("link", { href: args.link.trim() });
+        if (args.highlight === null) chain = chain.unsetMark("highlight");
+        else if (typeof args.highlight === "string") chain = chain.setMark("highlight", { color: args.highlight });
+        const style = {};
+        if (args.color !== void 0) style.color = args.color;
+        if (args.fontSize !== void 0) style.fontSize = args.fontSize;
+        if (Object.keys(style).length) {
+          chain = chain.setMark("textStyle", style);
+          if (Object.values(style).includes(null)) chain = chain.removeEmptyTextStyle();
+        }
+        chain.command((props) => {
+          tr = props.tr;
+          return guard.restore(props);
+        }).run();
+        const after = tr ? guard.mapped(tr) : range;
+        changed([after]);
+        const doc = ed2.state.doc;
+        return { range: after, text: doc.textBetween(after.from, after.to, "\n"), formatting: marksOn(doc, ed2.schema, after.from, after.to) };
+      }
+    };
+  };
+  const blockTypes = (ed) => BLOCK_TYPES.filter(([, node]) => !!ed.schema.nodes[node] && (!LIST_ITEMS[node] || !!ed.schema.nodes[LIST_ITEMS[node]]));
+  const headingLevels = (ed) => {
+    const ext = ed.extensionManager.extensions.find((e) => e.name === "heading");
+    return ext?.options?.levels ?? [1, 2, 3, 4, 5, 6];
+  };
+  const setBlockType = (ed) => {
+    const types = blockTypes(ed);
+    if (types.length < 2) return null;
+    const levels = ed.schema.nodes.heading ? headingLevels(ed) : [];
+    return {
+      name: "set_block_type",
+      title: "Set the block type",
+      description: "Turns every paragraph the range touches (or the one at the cursor) into " + types.map(([value, , what]) => `${value} (${what})`).join(", ") + ". The blocks are first taken out of any list, quote or code block, so one call switches between kinds. One undo step; the selection is left where it was. Returns the resulting `blocks` with their type, positions, text, level, alignment and the list or quote they are in.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...RANGE_PROPERTIES,
+          type: { type: "string", enum: types.map(([value]) => value), description: "What the blocks become." },
+          ...levels.length ? { level: { type: "integer", enum: levels, description: `Heading level for type "heading" (${levels.join(", ")}; 1 is the largest).` } } : {}
+        },
+        required: ["type"],
+        additionalProperties: false
+      },
+      annotations: { title: "Set the block type", ...WRITE_IDEMPOTENT2 },
+      handler: (args) => {
+        const ed2 = editor();
+        checkEditable(ed2);
+        const type = args.type;
+        if (type === "heading" && args.level === void 0) throw new Error(`Pass a heading "level" (${levels.join(", ")}).`);
+        if (type !== "heading" && args.level !== void 0) throw new Error('"level" only applies to type "heading".');
+        const range = targetRange(ed2, args, true);
+        const node = BLOCK_TYPES.find(([value]) => value === type)[1];
+        const guard = selectionGuard(ed2, range);
+        let tr = null;
+        let chain = ed2.chain().command(guard.select).clearNodes();
+        if (type === "heading") chain = chain.setNode("heading", { level: args.level });
+        else if (type === "code_block") chain = chain.setNode("codeBlock");
+        else if (type === "blockquote") chain = chain.wrapIn("blockquote");
+        else if (LIST_ITEMS[node]) chain = chain.toggleList(node, LIST_ITEMS[node]);
+        const ok = chain.command((props) => {
+          tr = props.tr;
+          return guard.restore(props);
+        }).run();
+        if (!ok || !tr) throw new Error(`Those blocks cannot become ${type} here (for example inside a table cell or a code block). Nothing was changed.`);
+        const after = guard.mapped(tr);
+        changed([after]);
+        return { type, range: after, blocks: blocksIn(ed2.state.doc, after.from, after.to) };
+      }
+    };
+  };
+  const setTextAlign = (ed) => {
+    const ext = ed.extensionManager.extensions.find((e) => e.name === "textAlign");
+    if (!ext) return null;
+    const alignments = (ext.options?.alignments ?? ["left", "center", "right", "justify"]).slice();
+    const types = ext.options?.types ?? ["heading", "paragraph"];
+    return {
+      name: "set_text_align",
+      title: "Align text",
+      description: `Aligns every ${types.join(" and ")} the range touches (or the one at the cursor): ${alignments.join(", ")}, or null for the default. One undo step; the selection is left where it was. Returns the resulting \`blocks\` with their alignment.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          ...RANGE_PROPERTIES,
+          align: { type: ["string", "null"], enum: [...alignments, null], description: "The alignment, or null for the default (usually left)." }
+        },
+        required: ["align"],
+        additionalProperties: false
+      },
+      annotations: { title: "Align text", ...WRITE_IDEMPOTENT2 },
+      handler: (args) => {
+        const ed2 = editor();
+        checkEditable(ed2);
+        const range = targetRange(ed2, args, true);
+        const blocks = blocksIn(ed2.state.doc, range.from, range.to);
+        if (!blocks.some((b) => types.includes(b.type))) {
+          throw new Error(`Only ${types.join(" and ")} blocks can be aligned; the range has ${[...new Set(blocks.map((b) => b.type))].join(", ") || "no text blocks"}.`);
+        }
+        const guard = selectionGuard(ed2, range);
+        let tr = null;
+        const chain = ed2.chain().command(guard.select);
+        (args.align === null ? chain.unsetTextAlign() : chain.setTextAlign(args.align)).command((props) => {
+          tr = props.tr;
+          return guard.restore(props);
+        }).run();
+        const after = tr ? guard.mapped(tr) : range;
+        changed([after]);
+        return { align: args.align, range: after, blocks: blocksIn(ed2.state.doc, after.from, after.to) };
+      }
+    };
+  };
+  return {
+    /** The formatting tools this editor's schema supports. */
+    tools(ed) {
+      return [formatText(ed), setBlockType(ed), setTextAlign(ed)].filter((t) => t !== null);
+    }
+  };
+}
+
 // src/agent/providers.ts
 var toEditor = (target) => "commands" in target ? target : target.editor;
 function selectionInfo(editor) {
@@ -707,7 +1029,7 @@ function createTextPresence(editor, providerId, option) {
         touch();
         return range2;
       }
-      const tr = replaceWithTextTransaction(ed.state, from, to, text);
+      const tr = closeHistory3(replaceWithTextTransaction(ed.state, from, to, text));
       const end = tr.mapping.map(to, 1);
       const range = { from: Math.min(tr.mapping.map(from, -1), end), to: end };
       ed.view.dispatch(tr.scrollIntoView());
@@ -744,6 +1066,7 @@ function createRichTextToolProvider(target, options) {
   const editor = () => toEditor(target);
   const charts = createDocumentChartTools(editor);
   const presence = createTextPresence(editor, options.id, options.presence);
+  const formatting = createDocumentFormatTools(editor, (ranges) => presence.changed(ranges.filter((r) => r.from < r.to)));
   const getText = {
     name: "get_text",
     title: "Get document text",
@@ -889,7 +1212,7 @@ function createRichTextToolProvider(target, options) {
         ...m,
         replacement: String(replace).replace(/\r\n?|\n/g, "\r")
       }));
-      const tr = ed.state.tr;
+      const tr = closeHistory3(ed.state.tr);
       const ends = applyReplacements(tr, chosen);
       ed.view.dispatch(tr.scrollIntoView());
       const ranges = chosen.map((m, i) => ({ from: tr.mapping.map(m.from, -1), to: ends[i] }));
@@ -954,7 +1277,7 @@ function createRichTextToolProvider(target, options) {
       const ed = editor();
       checkRange(ed, from, to);
       const { doc } = ed.state;
-      ed.view.dispatch(ed.state.tr.setSelection(TextSelection.between(doc.resolve(from), doc.resolve(to))));
+      ed.view.dispatch(ed.state.tr.setSelection(TextSelection2.between(doc.resolve(from), doc.resolve(to))));
       const selection = selectionInfo(ed);
       presence.show(selection.from, selection.to);
       return { selection };
@@ -1018,7 +1341,7 @@ function createRichTextToolProvider(target, options) {
       if (at !== void 0) {
         const size = ed.state.doc.content.size;
         if (at > size) throw new Error(`Position ${at} is outside the document (size ${size}).`);
-        ed.view.dispatch(ed.state.tr.setSelection(TextSelection.near(ed.state.doc.resolve(at))));
+        ed.view.dispatch(ed.state.tr.setSelection(TextSelection2.near(ed.state.doc.resolve(at))));
       }
       const action = operation;
       const state = getTableActionState(ed, action, params);
@@ -1035,11 +1358,14 @@ function createRichTextToolProvider(target, options) {
   return {
     id: options.id,
     namespace: options.namespace,
+    title: "Document",
+    description: "A rich text document: read and find text, insert, replace and format it, tables, and charts in the document.",
+    skill: "pixerate-rich-text",
     tools: () => {
       const ed = editor();
       if (!ed || ed.isDestroyed) return [];
       if (!ed.isEditable) return [getText, findText, ...charts.read()];
-      const tools = [getText, findText, insertText, replaceText, replaceRange, replaceSelection, setSelection];
+      const tools = [getText, findText, insertText, replaceText, replaceRange, replaceSelection, setSelection, ...formatting.tools(ed)];
       return [...tools, ...isTableEnabled(ed) ? [editTable] : [], ...charts.read(), ...charts.write()];
     },
     subscribe: (notify) => {
@@ -1387,6 +1713,9 @@ function createSpreadsheetToolProvider(controller, options) {
   return {
     id: options.id,
     namespace: options.namespace,
+    title: "Spreadsheet",
+    description: "A spreadsheet: read and set cells and ranges, insert and delete rows and columns, merge and transpose.",
+    skill: "pixerate-spreadsheet",
     tools: [getRange, setCell, setRange, insertRows, deleteRows, insertColumns, deleteColumns, mergeCells, unmergeCells, transposeRange]
   };
 }
@@ -1452,7 +1781,14 @@ function createEditorMcpToolProvider(options) {
       }
     });
   }
-  return { id: options.id, namespace: options.namespace, tools };
+  return {
+    id: options.id,
+    namespace: options.namespace,
+    title: "Canvas and prompt editor",
+    description: "The node canvas and the prompt: editor state, nodes and edges, layout, prompt text, and a view of the editor.",
+    skill: "pixerate-canvas",
+    tools
+  };
 }
 
 // src/agent/componentTools.ts
@@ -1648,7 +1984,14 @@ function createCanvasComponentToolProvider(controller, options = { id: "canvas-c
       )
     );
   }
-  return { id: options.id, namespace: options.namespace, tools };
+  return {
+    id: options.id,
+    namespace: options.namespace,
+    title: "Canvas components",
+    description: "Reusable canvas components: define them, place instances, manage variants and overrides.",
+    skill: "pixerate-canvas",
+    tools
+  };
 }
 export {
   CAPTURE_EXCLUDE_SELECTOR,
@@ -1677,9 +2020,13 @@ export {
   MCP_TOOL_VIEW_EDITOR,
   TOOL_BRIDGE_DEFAULT_PORT,
   TOOL_BRIDGE_PROTOCOL,
+  TOOL_DISCOVERY_TOOLS,
   TOOL_NAMESPACE_SEPARATOR,
   ToolRegistry,
   ToolRegistryError,
+  ToolRegistryView,
+  UNSAFE_JSON_KEYS,
+  baseToolName,
   captureInputSchema,
   captureOutputSize,
   cloneElementWithStyles,
@@ -1695,15 +2042,27 @@ export {
   createSpreadsheetToolProvider,
   createToolRegistry,
   elementToSvg,
+  errorResult,
+  isUnsafeJsonKey,
+  listSkills,
   normalizeSide,
+  parseSkillFrontmatter,
   planAgentCommand,
   planToolCall,
   rasterizeElement,
+  readSkillFile,
   resolveCaptureRequest,
+  searchTokens,
+  searchTools,
+  stripPrototypeKeys,
+  summarize,
   toCapturedImageData,
   toToolResult,
   toolCallToAgentCommand,
+  toolsetInstructions,
+  toolsetName,
   unionCaptureRects,
+  unknownToolMessage,
   validateAgentCommand,
   validateJsonSchema
 };

package/dist/agent/providers.d.cts

@@ -8,7 +8,7 @@ import { type AgentTypingOptions } from '../extensions/agent-caret.cjs';
 export interface ToolProviderOptions {
     /** Provider id (unique per registry). */
     id: string;
-    /** Always prefix tool names with `<namespace>__`. */
+    /** Tool-name prefix (`<namespace>__<name>`); defaults to the provider id, `''` for bare names. */
     namespace?: string;
 }
 /** A TipTap editor, or anything exposing one as `.editor` (e.g. `EditorController`). */
@@ -42,8 +42,10 @@ export interface RichTextToolProviderOptions extends ToolProviderOptions {
 }
 /**
  * Tools for a mounted rich-text editor: `get_text` and `find_text` (always),
- * plus `insert_text`, `replace_text`, `replace_range`, `replace_selection` and
- * `set_selection` while the editor is editable, `edit_table` when the
+ * plus `insert_text`, `replace_text`, `replace_range`, `replace_selection`,
+ * `set_selection` and the formatting tools (`format_text`, `set_block_type`,
+ * `set_text_align`, as far as the schema supports them) while the editor is
+ * editable, `edit_table` when the
  * schema has tables (`createRichTextPreset`'s `table`), and the chart tools
  * (`list_document_charts`; `insert_chart`, `update_chart_in_document` and
  * `insert_sparkline` while editable) when it has charts (`chart`).

package/dist/agent/providers.d.ts

@@ -8,7 +8,7 @@ import { type AgentTypingOptions } from '../extensions/agent-caret.js';
 export interface ToolProviderOptions {
     /** Provider id (unique per registry). */
     id: string;
-    /** Always prefix tool names with `<namespace>__`. */
+    /** Tool-name prefix (`<namespace>__<name>`); defaults to the provider id, `''` for bare names. */
     namespace?: string;
 }
 /** A TipTap editor, or anything exposing one as `.editor` (e.g. `EditorController`). */
@@ -42,8 +42,10 @@ export interface RichTextToolProviderOptions extends ToolProviderOptions {
 }
 /**
  * Tools for a mounted rich-text editor: `get_text` and `find_text` (always),
- * plus `insert_text`, `replace_text`, `replace_range`, `replace_selection` and
- * `set_selection` while the editor is editable, `edit_table` when the
+ * plus `insert_text`, `replace_text`, `replace_range`, `replace_selection`,
+ * `set_selection` and the formatting tools (`format_text`, `set_block_type`,
+ * `set_text_align`, as far as the schema supports them) while the editor is
+ * editable, `edit_table` when the
  * schema has tables (`createRichTextPreset`'s `table`), and the chart tools
  * (`list_document_charts`; `insert_chart`, `update_chart_in_document` and
  * `insert_sparkline` while editable) when it has charts (`chart`).

package/dist/animation-editor/effect-tools.d.cts

@@ -8,7 +8,7 @@ import type { AnimationEditorController } from './controller.cjs';
 export interface AnimationEffectsToolProviderOptions {
     /** Provider id (unique per registry). Default `animation-effects`. */
     id?: string;
-    /** Always prefix tool names with `<namespace>__`. */
+    /** Tool-name prefix (`<namespace>__<name>`); defaults to the provider id, `''` for bare names. */
     namespace?: string;
     /** The scene cannot be edited: write tools are hidden. A string is the reason. */
     readOnly?: boolean | string | (() => boolean | string);

package/dist/animation-editor/effect-tools.d.ts

@@ -8,7 +8,7 @@ import type { AnimationEditorController } from './controller.js';
 export interface AnimationEffectsToolProviderOptions {
     /** Provider id (unique per registry). Default `animation-effects`. */
     id?: string;
-    /** Always prefix tool names with `<namespace>__`. */
+    /** Tool-name prefix (`<namespace>__<name>`); defaults to the provider id, `''` for bare names. */
     namespace?: string;
     /** The scene cannot be edited: write tools are hidden. A string is the reason. */
     readOnly?: boolean | string | (() => boolean | string);