more fixes

Author: goanpeca

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

@@ -16,73 +16,11 @@ import type {
   LexicalMetadata,
   RegisteredNodeInfo,
 } from './types';
+import type { ToolExecutionContext } from '@datalayer/jupyter-react';
 
 // Re-export types for convenience
 export type { LexicalBlock, LexicalMetadata, RegisteredNodeInfo };
-
-/**
- * Base tool execution context - common to all operations
- */
-export interface BaseExecutionContext {
-  /**
-   * Datalayer SDK for API operations
-   * (Required for notebook/runtime creation tools)
-   */
-  sdk?: unknown; // DatalayerClient (avoid circular import)
-
-  /**
-   * Authentication provider
-   * (Required for authenticated operations)
-   */
-  auth?: unknown; // AuthProvider (avoid circular import)
-
-  /**
-   * Response format for tool results
-   * - "json": Standard JSON format (default) - structured data
-   * - "toon": TOON format - human/LLM-readable with compact syntax
-   */
-  format?: 'json' | 'toon';
-
-  /**
-   * Platform-agnostic command execution callback.
-   * Allows operations to invoke platform-specific commands without direct dependencies.
-   *
-   * Operations call this with namespaced command names (e.g., "notebook.insertCell", "lexical.insertBlock").
-   * The platform adapter is responsible for mapping these to the appropriate implementation.
-   *
-   * @param command - Command name with namespace prefix (e.g., "notebook.insertCell")
-   * @param args - Command arguments (platform adapter handles any necessary conversions)
-   * @returns Command result
-   */
-  executeCommand?: <T = void>(command: string, args: unknown) => Promise<T>;
-
-  /**
-   * Platform-specific extras (escape hatch for special cases)
-   * Use this to pass additional context that doesn't fit in the standard interface.
-   */
-  extras?: Record<string, unknown>;
-}
-
-/**
- * Lexical-specific execution context
- * Used by all Lexical block operations (insertBlock, deleteBlock, readBlocks)
- */
-export interface LexicalExecutionContext extends BaseExecutionContext {
-  /**
-   * Lexical document ID - universal identifier for both local and remote documents
-   * - Local documents: Same as file URI (e.g., "file:///path/to/document.lexical")
-   * - Remote documents: Datalayer document UID (e.g., "01KAJ42KE2XKM7NBNZV568KXQX")
-   */
-  lexicalId: string;
-
-  /**
-   * Executor for calling lexical store operations
-   * Used in ag-ui environments to directly call store methods
-   */
-  executor?: {
-    execute<T = unknown>(operationName: string, args?: unknown): Promise<T>;
-  };
-}
+export type { ToolExecutionContext };
 
 /**
  * Core tool operation interface - platform agnostic.
@@ -107,11 +45,11 @@ export interface ToolOperation<TParams, TResult> {
    * ToolDefinition (schema), not here. Operations are pure implementation.
    *
    * @param params - Tool-specific parameters
-   * @param context - Execution context (lexicalId, SDK, auth)
+   * @param context - Execution context (documentId, executor, SDK, auth)
    * @returns Operation result
    * @throws Error if operation fails
    */
-  execute(params: TParams, context: LexicalExecutionContext): Promise<TResult>;
+  execute(params: TParams, context: ToolExecutionContext): Promise<TResult>;
 }
 
 /**

packages/lexical/src/tools/operations/deleteBlock.ts

@@ -10,10 +10,7 @@
  * @module tools/core/operations/deleteBlock
  */
 
-import type {
-  ToolOperation,
-  LexicalExecutionContext,
-} from '../core/interfaces';
+import type { ToolOperation, ToolExecutionContext } from '../core/interfaces';
 import type { LexicalBlock } from '../core/types';
 import { readAllBlocksOperation } from './readAllBlocks';
 import { validateWithZod } from '../core/zodUtils';
@@ -53,20 +50,20 @@ export interface DeleteBlockResult {
  *
  * IDs are stable identifiers so deletion order does not matter (unlike index-based deletion).
  *
- * Uses lexicalId as the universal identifier (matches Lexical component).
+ * Uses documentId as the universal identifier (matches Lexical component).
  *
  * Architecture:
- * - Core layer: Works with lexicalId (platform-agnostic)
- * - VS Code adapter: Converts lexicalId → documentUri via registry
+ * - Core layer: Works with documentId (platform-agnostic)
+ * - VS Code adapter: Converts documentId → documentUri via registry
  * - Internal command: Uses documentUri to send message to webview
- * - Webview: Lexical component uses same lexicalId
+ * - Webview: Lexical component uses same documentId
  *
  * @example
  * ```typescript
  * // Delete blocks
  * await deleteBlockOperation.execute(
  *   { ids: ["block-123", "block-456", "block-789"] },
- *   { lexicalId: "doc-1", executeCommand }
+ *   { documentId: "doc-1", executeCommand }
  * );
  * ```
  */
@@ -78,7 +75,7 @@ export const deleteBlockOperation: ToolOperation<
 
   async execute(
     params: unknown,
-    context: LexicalExecutionContext,
+    context: ToolExecutionContext,
   ): Promise<DeleteBlockResult> {
     // Validate params using Zod
     const validatedParams = validateWithZod(
@@ -88,13 +85,13 @@ export const deleteBlockOperation: ToolOperation<
     );
 
     const { ids } = validatedParams;
-    const { lexicalId } = context;
+    const { documentId } = context;
 
     // Validate context
-    if (!lexicalId) {
+    if (!documentId) {
       throw new Error(
-        'Lexical ID is required for deleteBlock operation. ' +
-          'Ensure the tool execution context includes a valid lexicalId.',
+        'Document ID is required for deleteBlock operation. ' +
+          'Ensure the tool execution context includes a valid documentId.',
       );
     }
 

packages/lexical/src/tools/operations/executeCode.ts

@@ -11,10 +11,7 @@
  * @module tools/operations/executeCode
  */
 
-import type {
-  ToolOperation,
-  LexicalExecutionContext,
-} from '../core/interfaces';
+import type { ToolOperation, ToolExecutionContext } from '../core/interfaces';
 import { validateWithZod } from '../core/zodUtils';
 import {
   executeCodeParamsSchema,
@@ -54,11 +51,11 @@ export const executeCodeOperation: ToolOperation<
 
   async execute(
     params: unknown,
-    context: LexicalExecutionContext,
+    context: ToolExecutionContext,
   ): Promise<ExecuteCodeResult> {
     console.log('[executeCodeOperation] Called with params:', params);
     console.log('[executeCodeOperation] Context:', {
-      lexicalId: context.lexicalId,
+      documentId: context.documentId,
       hasExecutor: !!context.executor,
     });
 
@@ -71,12 +68,12 @@ export const executeCodeOperation: ToolOperation<
 
     console.log('[executeCodeOperation] Validated params:', validatedParams);
 
-    const { lexicalId } = context;
+    const { documentId } = context;
 
-    if (!lexicalId) {
+    if (!documentId) {
       return {
         success: false,
-        error: 'Lexical ID is required for this operation.',
+        error: 'Document ID is required for this operation.',
       };
     }
 
@@ -95,10 +92,10 @@ export const executeCodeOperation: ToolOperation<
       });
 
       // Call executor (uses this.name for DRY principle)
-      const result = await context.executor.execute<ExecuteCodeResult>(
+      const result = (await context.executor.execute(
         this.name,
         validatedParams,
-      );
+      )) as ExecuteCodeResult;
 
       console.log('[executeCodeOperation] Executor result:', result);
       return result;

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

@@ -10,10 +10,7 @@
  * @module tools/core/operations/insertBlock
  */
 
-import type {
-  ToolOperation,
-  LexicalExecutionContext,
-} from '../core/interfaces';
+import type { ToolOperation, ToolExecutionContext } from '../core/interfaces';
 import { validateWithZod } from '../core/zodUtils';
 import {
   insertBlockParamsSchema,
@@ -52,7 +49,7 @@ export const insertBlockOperation: ToolOperation<
 
   async execute(
     params: unknown,
-    context: LexicalExecutionContext,
+    context: ToolExecutionContext,
   ): Promise<InsertBlockResult> {
     // Validate params using Zod
     const validatedParams = validateWithZod(
@@ -62,13 +59,13 @@ export const insertBlockOperation: ToolOperation<
     );
 
     const { afterId, type, source, properties } = validatedParams;
-    const { lexicalId } = context;
+    const { documentId } = context;
 
     // Validate context
-    if (!lexicalId) {
+    if (!documentId) {
       throw new Error(
-        'Lexical ID is required for insertBlock operation. ' +
-          'Ensure the tool execution context includes a valid lexicalId.',
+        'Document ID is required for insertBlock operation. ' +
+          'Ensure the tool execution context includes a valid documentId.',
       );
     }
 

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

@@ -13,10 +13,7 @@
  * @module tools/core/operations/listAvailableBlocks
  */
 
-import type {
-  ToolOperation,
-  LexicalExecutionContext,
-} from '../core/interfaces';
+import type { ToolOperation, ToolExecutionContext } from '../core/interfaces';
 import type { RegisteredNodeInfo } from '../core/types';
 import { validateWithZod } from '../core/zodUtils';
 import {
@@ -307,7 +304,7 @@ export const listAvailableBlocksOperation: ToolOperation<
 
   async execute(
     params: unknown,
-    context: LexicalExecutionContext,
+    context: ToolExecutionContext,
   ): Promise<ListAvailableBlocksResult> {
     // Validate params using Zod
     const validatedParams = validateWithZod(
@@ -317,25 +314,28 @@ export const listAvailableBlocksOperation: ToolOperation<
     );
 
     const { category } = validatedParams;
-    const { lexicalId } = context;
+    const { documentId } = context;
 
     try {
       let types = DEFAULT_BLOCK_TYPES;
 
       // Try to get dynamically registered types from the document
-      // This is optional - if no lexicalId or executor, we fall back to DEFAULT_BLOCK_TYPES
-      if (lexicalId && context.executor) {
+      // This is optional - if no documentId or executor, we fall back to DEFAULT_BLOCK_TYPES
+      if (documentId && context.executor) {
         try {
           // Call executor to get registered nodes
-          const registeredNodes = await context.executor.execute<
-            RegisteredNodeInfo[]
-          >('listAvailableBlocks', {});
+          const registeredNodes = (await context.executor.execute(
+            'listAvailableBlocks',
+            {},
+          )) as RegisteredNodeInfo[];
 
           if (registeredNodes && registeredNodes.length > 0) {
             // Lexical nodes have types like: "paragraph", "heading", "code", "quote",
             // "list", "listitem", "table", "equation", "image", "youtube", "jupyter-cell"
             const registeredTypes = new Set(
-              registeredNodes.map(node => node.type.toLowerCase()),
+              registeredNodes.map((node: RegisteredNodeInfo) =>
+                node.type.toLowerCase(),
+              ),
             );
 
             // Filter to only schemas for registered node types

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

@@ -10,10 +10,7 @@
  * @module tools/core/operations/readAllBlocks
  */
 
-import type {
-  ToolOperation,
-  LexicalExecutionContext,
-} from '../core/interfaces';
+import type { ToolOperation, ToolExecutionContext } from '../core/interfaces';
 import type { LexicalBlock, BriefBlock } from '../core/types';
 import { validateWithZod } from '../core/zodUtils';
 import {
@@ -54,7 +51,7 @@ export const readAllBlocksOperation: ToolOperation<
 
   async execute(
     params: unknown,
-    context: LexicalExecutionContext,
+    context: ToolExecutionContext,
   ): Promise<ReadAllBlocksResult> {
     // Validate params using Zod
     const validatedParams = validateWithZod(
@@ -64,13 +61,13 @@ export const readAllBlocksOperation: ToolOperation<
     );
 
     const { format = 'brief' } = validatedParams;
-    const { lexicalId } = context;
+    const { documentId } = context;
 
     // Validate context
-    if (!lexicalId) {
+    if (!documentId) {
       throw new Error(
-        'Lexical ID is required for readAllBlocks operation. ' +
-          'Ensure the tool execution context includes a valid lexicalId.',
+        'Document ID is required for readAllBlocks operation. ' +
+          'Ensure the tool execution context includes a valid documentId.',
       );
     }
 
@@ -84,9 +81,9 @@ export const readAllBlocksOperation: ToolOperation<
 
     try {
       // Call executor with format parameter
-      const blocks = await context.executor.execute<
-        LexicalBlock[] | BriefBlock[]
-      >(this.name, { format });
+      const blocks = (await context.executor.execute(this.name, {
+        format,
+      })) as LexicalBlock[] | BriefBlock[];
 
       return {
         success: true,