Update lexical tools for additional blocks and robustness

Author: goanpeca

packages/lexical/src/state/LexicalAdapter.ts

@@ -45,7 +45,7 @@ export type InsertBlockMutation = {
   id: string; // lexical document ID
   type: string;
   source: string;
-  properties?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
   afterId: string;
 };
 
@@ -54,7 +54,7 @@ export type InsertBlocksMutation = {
   blocks: Array<{
     type: string;
     source: string;
-    properties?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
   }>;
   afterId: string;
 };
@@ -64,7 +64,7 @@ export type UpdateBlockMutation = {
   blockId: string;
   type?: string;
   source?: string;
-  properties?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
 };
 
 export type DeleteBlockMutation = {
@@ -91,15 +91,15 @@ export type LexicalState = ILexicalsState & {
     id: string,
     type?: string,
     source?: string,
-    properties?: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
     afterId?: string,
-  ) => Promise<void>;
+  ) => Promise<OperationResult>;
   updateBlock: (
     id: string,
     blockId?: string,
     type?: string,
     source?: string,
-    properties?: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
   ) => Promise<void>;
   deleteBlock: (id: string, blockId?: string) => Promise<void>;
   readBlock: (id: string, blockId?: string) => Promise<LexicalBlock | null>;
@@ -120,6 +120,12 @@ export type LexicalState = ILexicalsState & {
 
   // Additional utility methods
   getBlockCount: (id: string) => Promise<number>;
+  listAvailableBlocks: (id: string) => Promise<{
+    success: boolean;
+    types?: any[];
+    count?: number;
+    error?: string;
+  }>;
   reset: () => void;
 };
 
@@ -145,14 +151,14 @@ export const lexicalStore = createStore<LexicalState>((set, get) => ({
     id: string,
     type?: string,
     source?: string,
-    properties?: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
     afterId?: string,
-  ): Promise<void> => {
+  ): Promise<OperationResult> => {
     // Accept object from executor, destructure it
     const params =
       typeof id === 'object'
         ? (id as any)
-        : { id, type, source, properties, afterId };
+        : { id, type, source, metadata, afterId };
 
     const adapter = get().lexicals.get(params.id)?.adapter;
     if (!adapter) {
@@ -163,27 +169,30 @@ export const lexicalStore = createStore<LexicalState>((set, get) => ({
       block_id: '', // Will be assigned by editor
       block_type: params.type,
       source: params.source,
-      metadata: params.properties,
+      metadata: params.metadata,
     };
 
     const result = await adapter.insertBlock(block, params.afterId);
     if (!result.success) {
       throw new Error(result.error || 'Failed to insert block');
     }
+
+    // Return the result with blockId
+    return result;
   },
 
   updateBlock: async (
     id: string,
     blockId?: string,
     type?: string,
     source?: string,
-    properties?: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
   ): Promise<void> => {
     // Accept object from executor, destructure it
     const params =
       typeof id === 'object'
         ? (id as any)
-        : { id, blockId, type, source, properties };
+        : { id, blockId, type, source, metadata };
 
     const adapter = get().lexicals.get(params.id)?.adapter;
     if (!adapter) {
@@ -203,7 +212,7 @@ export const lexicalStore = createStore<LexicalState>((set, get) => ({
       source: params.source ?? existingBlock.source,
       metadata: {
         ...existingBlock.metadata,
-        ...params.properties,
+        ...params.metadata,
       },
     };
 
@@ -321,6 +330,45 @@ export const lexicalStore = createStore<LexicalState>((set, get) => ({
     return blocks.length;
   },
 
+  listAvailableBlocks: async (
+    id: string,
+  ): Promise<{
+    success: boolean;
+    types?: any[];
+    count?: number;
+    error?: string;
+  }> => {
+    console.log('[LexicalState] 🔍 listAvailableBlocks CALLED with:', { id });
+
+    // Delegate to adapter (following consistent pattern with all other operations)
+    const params = typeof id === 'object' ? id : { id };
+    console.log('[LexicalState] 📦 Processed params:', params);
+
+    // Special case: this operation is static and doesn't require a document
+    // If no document is found, call the operation directly
+    const adapter = get().lexicals.get(params.id as string)?.adapter;
+    console.log('[LexicalState] 🔧 Adapter found?', !!adapter);
+
+    if (!adapter) {
+      console.log('[LexicalState] 🚀 Calling operation directly (no adapter)');
+      // Call operation directly without adapter (static operation)
+      const { listAvailableBlocksOperation } =
+        await import('../tools/operations/listAvailableBlocks');
+      console.log('[LexicalState] 📥 Operation imported, executing...');
+      const result = await listAvailableBlocksOperation.execute(
+        { type: 'all' },
+        { documentId: 'static', executor: null as any },
+      );
+      console.log('[LexicalState] ✅ Operation result:', result);
+      return result;
+    }
+
+    console.log('[LexicalState] 🔗 Delegating to adapter');
+    const result = await adapter.listAvailableBlocks();
+    console.log('[LexicalState] ✅ Adapter result:', result);
+    return result;
+  },
+
   reset: () => set({ lexicals: new Map() }),
 }));
 

packages/lexical/src/state/LexicalState.ts

@@ -58,6 +58,11 @@ export class DefaultExecutor implements ToolExecutor {
     operationName: string,
     args?: unknown,
   ): Promise<T> {
+    console.log('[DefaultExecutor] 🚀 execute CALLED');
+    console.log('[DefaultExecutor] Operation:', operationName);
+    console.log('[DefaultExecutor] Args:', args);
+    console.log('[DefaultExecutor] LexicalId:', this.lexicalId);
+
     // Get the store method directly (1:1 mapping, no transformation)
     const method = (this.store as unknown as Record<string, unknown>)[
       operationName
@@ -78,12 +83,16 @@ export class DefaultExecutor implements ToolExecutor {
         ? { id: this.lexicalId, ...args }
         : { id: this.lexicalId };
 
+    console.log('[DefaultExecutor] 📦 Payload to store method:', payload);
+
     try {
+      console.log('[DefaultExecutor] 📞 Calling store method...');
       const result = await (method as (args: unknown) => Promise<T>).call(
         this.store,
         payload,
       );
 
+      console.log('[DefaultExecutor] ✅ Store method returned:', result);
       return result;
     } catch (error) {
       console.error('[DefaultExecutor] ❌ ERROR calling store method:', error);

packages/lexical/src/tools/core/executor.ts

@@ -145,18 +145,14 @@ export interface LexicalBlock {
 export type BlockFormat = 'brief' | 'detailed';
 
 /**
- * Brief block representation for structure queries
- * Includes block_id, block_type, and a 40-char content preview
+ * Brief block representation for structure queries (CSV-serializable)
+ * Fields: block_id, block_type, preview, collapsible
  */
 export interface BriefBlock {
-  /** Unique block identifier */
   block_id: string;
-
-  /** Block type identifier */
   block_type: string;
-
-  /** 40-character preview of block content (empty for horizontalrule) */
   preview: string;
+  collapsible?: string;
 }
 
 /**

packages/lexical/src/tools/core/types.ts

@@ -19,8 +19,8 @@ import { insertBlockParamsSchema } from '../schemas/insertBlock';
  *
  * Supports inserting various block types:
  * - paragraph: Regular text paragraph
- * - heading: Semantic HTML heading (NOT markdown - use plain text, specify tag property for h1-h6)
- * - code: Code block (specify language in properties)
+ * - heading: Semantic HTML heading (NOT markdown - use plain text, specify tag in metadata for h1-h6)
+ * - code: Code block (specify language in metadata)
  * - quote: Blockquote
  * - list/listitem: List blocks
  * - jupyter-cell: Executable Jupyter code cells
@@ -30,7 +30,7 @@ export const insertBlockTool: ToolDefinition = {
   displayName: 'Insert Lexical Block',
   toolReferenceName: 'insertBlock',
   description:
-    "Insert different type of content with blocks. Use listAvailableBlocks to get availables blocks. When inserting MULTIPLE blocks sequentially (e.g., creating a document outline with heading + paragraph + code), ALWAYS use afterId: 'BOTTOM' for each insertion to append blocks in order. For single insertions, call readAllBlocks first to see document structure. Position blocks using afterId: 'TOP' (beginning), 'BOTTOM' (end - REQUIRED for sequential inserts), or a specific block_id value from readAllBlocks. IMPORTANT: heading blocks are semantic HTML (NOT markdown) - use plain text in source field without # symbols, specify tag property (h1-h6) instead. Use listAvailableBlocks to see all supported types. Works on active .lexical file.",
+    "CRITICAL: DO NOT use markdown syntax in source field. Heading blocks use PLAIN TEXT (no # symbols) - specify tag metadata (h1-h6) instead. Inline formatting like **bold** or *italic* is automatically converted. ALWAYS call listAvailableBlocks FIRST to see block types and required metadata format. Insert different types of content blocks. When inserting MULTIPLE blocks sequentially (e.g., creating a document outline with heading + paragraph + code), ALWAYS use afterId: 'BOTTOM' for each insertion to append blocks in order. For single insertions, call readAllBlocks first to see document structure. Position blocks using afterId: 'TOP' (beginning), 'BOTTOM' (end - REQUIRED for sequential inserts), or a specific block_id value from readAllBlocks. To insert blocks INSIDE a collapsible: 1) First insert collapsible (type='collapsible'), which returns a blockId, 2) Then insert nested blocks with metadata.collapsible set to that RETURNED BLOCK ID (NOT 'TOP' or 'BOTTOM'). Example: result = insertBlock({type: 'collapsible', source: 'Section', afterId: 'BOTTOM'}); insertBlock({type: 'paragraph', source: 'text', metadata: {collapsible: result.blockId}, afterId: 'BOTTOM'}). DO NOT use position markers (TOP/BOTTOM) as collapsible IDs - they are only for afterId positioning. Works on active .lexical file.",
 
   parameters: zodToToolParameters(insertBlockParamsSchema),
 

packages/lexical/src/tools/definitions/insertBlock.ts

@@ -31,20 +31,20 @@ export const listAvailableBlocksTool: ToolDefinition = {
   displayName: 'List Available Lexical Blocks',
   toolReferenceName: 'listAvailableBlocks',
   description:
-    "Discover available block types for the currently open Lexical document. Returns schema for all registered blocks including: 'jupyter-cell' (executable code cell with language property), standard blocks (paragraph, heading [NOT markdown - semantic HTML with tag property], code, quote, list, table). Use this to see exact block type names and required properties before calling insertBlock.",
+    "Discover available block types for the currently open Lexical document. Available blocks: paragraph, heading, quote, code, list, horizontalrule, jupyter-cell (executable), equation, image, youtube (video embed), table (data table), collapsible (expandable section). Returns detailed schema including required/optional metadata for each block type. Set type parameter to specific block type (e.g., 'youtube', 'table') or 'all' (default) for all blocks. Use this BEFORE calling insertBlock to see exact type names and required metadata format.",
 
   parameters: zodToToolParameters(listAvailableBlocksParamsSchema),
 
   operation: 'listAvailableBlocks',
 
   config: {
-    confirmationMessage: (params: { category?: string }) =>
-      params.category
-        ? `List available ${params.category} block types?`
+    confirmationMessage: (params: { type?: string }) =>
+      params.type && params.type !== 'all'
+        ? `List details for '${params.type}' block type?`
         : 'List all available block types?',
-    invocationMessage: (params: { category?: string }) =>
-      params.category
-        ? `Listing ${params.category} block types`
+    invocationMessage: (params: { type?: string }) =>
+      params.type && params.type !== 'all'
+        ? `Listing '${params.type}' block type details`
         : 'Listing all available block types',
     requiresConfirmation: false,
     canBeReferencedInPrompt: true,

packages/lexical/src/tools/definitions/listAvailableBlocks.ts

@@ -24,7 +24,7 @@ export const readAllBlocksTool: ToolDefinition = {
   displayName: 'Read All Lexical Blocks',
   toolReferenceName: 'readAllBlocks',
   description:
-    "Read all blocks from the currently open Lexical document. Use listAvailableBlocks to get available blocks. Supports two response formats: 'brief' (default, ~1,100 tokens) returns block_id, block_type, and 40-char content preview for structure queries; 'detailed' (~20,000 tokens) returns full content with source, metadata, and properties. Use brief when you need to see document structure, count blocks, or quickly scan content. Use detailed when you need to read full content. Brief format preview shows: lists as comma-separated items, code/jupyter-cell as first line, horizontalrule as empty string. Returns array of blocks with: block_id (stable identifier for insertion), block_type (e.g. 'heading', 'paragraph', 'jupyter-cell'), preview (brief only), and optionally source/metadata (detailed only). CRITICAL: Use the block_id values from this result for insertBlock's afterId parameter. Works on active .lexical file.",
+    "Read all blocks from the currently open Lexical document. Use listAvailableBlocks to get available block types. Supports two response formats: 'brief' (default, ~1,100 tokens) returns block_id, block_type, and 40-char content preview for structure queries; 'detailed' (~20,000 tokens) returns full content with source, metadata, and properties. Use brief when you need to see document structure, count blocks, or quickly scan content. Use detailed when you need to read full content. Brief format preview shows: lists as comma-separated items, code/jupyter-cell as first line, horizontalrule as empty string. Returns array of blocks with: block_id (stable identifier for insertion), block_type (e.g. 'heading', 'paragraph', 'jupyter-cell'), preview (brief only), and optionally source/metadata (detailed only). CRITICAL: Use the block_id values from this result for insertBlock's afterId parameter. Works on active .lexical file.",
 
   parameters: zodToToolParameters(readAllBlocksParamsSchema),
 

packages/lexical/src/tools/definitions/readAllBlocks.ts

@@ -24,7 +24,7 @@ export const readBlockTool: ToolDefinition = {
   displayName: 'Read Lexical Block',
   toolReferenceName: 'readBlock',
   description:
-    "Read a single block from the currently open Lexical document by its block_id. Use listAvailableBlocks to get available blocks. Returns the block with: block_id, block_type (e.g. 'heading', 'paragraph', 'jupyter-cell'), source (content as string), metadata (properties like level, language). Use block_id values from readAllBlocks. Works on active .lexical file.",
+    "Read a single block from the currently open Lexical document by its block_id. Use listAvailableBlocks to get available block types. Returns the block with: block_id, block_type (e.g. 'heading', 'paragraph', 'jupyter-cell'), source (content as string), metadata (properties like level, language). Use block_id values from readAllBlocks. Works on active .lexical file.",
 
   parameters: zodToToolParameters(readBlockParamsSchema),
 

packages/lexical/src/tools/definitions/readBlock.ts

@@ -17,14 +17,14 @@ import { updateBlockParamsSchema } from '../schemas/updateBlock';
 /**
  * Tool definition for updating an existing block
  *
- * Modifies block type, source content, and/or properties.
+ * Modifies block type, source content, and/or metadata.
  */
 export const updateBlockTool: ToolDefinition = {
   name: 'datalayer_updateBlock',
   displayName: 'Update Lexical Block',
   toolReferenceName: 'updateBlock',
   description:
-    'Update an existing block in the currently open Lexical document. Use listAvailableBlocks to get available blocks. Can modify block type, source content, and/or properties. Requires id from readAllBlocks. At least one of type, source, or properties must be provided. Properties are merged with existing metadata. Works on active .lexical file.',
+    'Update an existing block in the currently open Lexical document. CRITICAL: DO NOT use markdown syntax (like # for headings) in source field - use plain text and specify block type/metadata instead. Inline formatting like **bold** or *italic* is automatically converted. Use listAvailableBlocks to get available block types. Can modify block type, source content, and/or metadata. Requires id from readAllBlocks. At least one of type, source, or metadata must be provided. Metadata is merged with existing metadata. Works on active .lexical file.',
 
   parameters: zodToToolParameters(updateBlockParamsSchema),
 
@@ -35,12 +35,12 @@ export const updateBlockTool: ToolDefinition = {
       id: string;
       type?: string;
       source?: string;
-      properties?: Record<string, unknown>;
+      metadata?: Record<string, unknown>;
     }) => {
       const updates: string[] = [];
       if (params.type) updates.push(`type to ${params.type}`);
       if (params.source) updates.push('source');
-      if (params.properties) updates.push('properties');
+      if (params.metadata) updates.push('metadata');
       return `Update block ${params.id} (${updates.join(', ')})?`;
     },
     invocationMessage: (params: { id: string }) =>

packages/lexical/src/tools/definitions/updateBlock.ts

@@ -136,8 +136,18 @@ export const deleteBlockOperation: ToolOperation<
       // Store information about blocks before deletion
       const deletedBlocks: DeletedBlockInfo[] = [];
 
-      // Delete each block (order doesn't matter - IDs are stable)
-      for (const id of ids) {
+      // Sort IDs in reverse order to delete children before parents (collapsibles last)
+      // This prevents cascading deletions from causing "block not found" errors
+      const sortedIds = [...ids].sort((a, b) => {
+        // Find positions in document
+        const indexA = blocks.findIndex(block => block.block_id === a);
+        const indexB = blocks.findIndex(block => block.block_id === b);
+        // Sort in reverse order (higher index first)
+        return indexB - indexA;
+      });
+
+      // Delete each block in reverse order
+      for (const id of sortedIds) {
         // Find and store block info before deletion
         const block = blocks.find(b => b.block_id === id);
 
@@ -147,16 +157,30 @@ export const deleteBlockOperation: ToolOperation<
         }
 
         // Execute deletion via executor
-        await context.executor!.execute(this.name, {
-          blockId: id,
-        });
-
-        // Track deletion
-        deletedBlocks.push({
-          id: block.block_id,
-          type: block.block_type,
-          source: block.source,
-        });
+        // Catch "block not found" errors - block was already deleted by cascading deletion
+        try {
+          await context.executor!.execute(this.name, {
+            blockId: id,
+          });
+
+          // Track successful deletion
+          deletedBlocks.push({
+            id: block.block_id,
+            type: block.block_type,
+            source: block.source,
+          });
+        } catch (error) {
+          // If block not found, it was likely deleted by cascading deletion (parent collapsible removed)
+          // Skip and continue - this is expected behavior
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+          if (errorMessage.includes('not found')) {
+            // Block was already deleted (cascaded), skip it
+            continue;
+          }
+          // Re-throw other errors
+          throw error;
+        }
       }
 
       // Format message similar to deleteCell pattern