Moar tools

Author: goanpeca

packages/lexical/src/state/LexicalAdapter.ts

@@ -50,9 +50,11 @@ export interface OperationResult {
 export class LexicalAdapter {
   private _editor: LexicalEditor;
   private _defaultBlockType: string = 'paragraph';
+  private _serviceManager?: any; // ServiceManager from @jupyterlab/services
 
-  constructor(editor: LexicalEditor) {
+  constructor(editor: LexicalEditor, serviceManager?: any) {
     this._editor = editor;
+    this._serviceManager = serviceManager;
   }
 
   /**
@@ -562,4 +564,112 @@ export class LexicalAdapter {
         return null;
     }
   }
+
+  /**
+   * Execute code directly in the kernel without creating a block.
+   *
+   * This method sends code execution requests directly to the kernel,
+   * bypassing the lexical document model. Useful for:
+   * - Variable inspection
+   * - Environment setup
+   * - Background tasks
+   * - Tool introspection
+   *
+   * @param code - Code to execute
+   * @param options - Execution options
+   * @returns Promise with execution result including outputs
+   */
+  async executeCode(
+    code: string,
+    options: {
+      storeHistory?: boolean;
+      silent?: boolean;
+      stopOnError?: boolean;
+    } = {},
+  ): Promise<{
+    success: boolean;
+    outputs?: Array<{
+      type: 'stream' | 'execute_result' | 'display_data' | 'error';
+      content: unknown;
+    }>;
+    executionCount?: number;
+    error?: string;
+  }> {
+    if (!this._serviceManager) {
+      return {
+        success: false,
+        error:
+          'No ServiceManager available. LexicalAdapter requires a ServiceManager to execute code.',
+      };
+    }
+
+    const kernel = this._serviceManager.sessions?.running()?.next()
+      ?.value?.kernel;
+
+    if (!kernel) {
+      return {
+        success: false,
+        error: 'No active kernel session',
+      };
+    }
+
+    try {
+      const future = kernel.requestExecute({
+        code,
+        stop_on_error: options.stopOnError ?? true,
+        store_history: options.storeHistory ?? false,
+        silent: options.silent ?? false,
+        allow_stdin: false,
+      });
+
+      const outputs: Array<{
+        type: 'stream' | 'execute_result' | 'display_data' | 'error';
+        content: unknown;
+      }> = [];
+
+      let executionCount: number | undefined;
+
+      // Collect outputs
+      future.onIOPub = (msg: any) => {
+        const msgType = msg.header.msg_type;
+
+        if (msgType === 'stream') {
+          outputs.push({
+            type: 'stream',
+            content: msg.content,
+          });
+        } else if (msgType === 'execute_result') {
+          outputs.push({
+            type: 'execute_result',
+            content: msg.content,
+          });
+          executionCount = (msg.content as any).execution_count;
+        } else if (msgType === 'display_data') {
+          outputs.push({
+            type: 'display_data',
+            content: msg.content,
+          });
+        } else if (msgType === 'error') {
+          outputs.push({
+            type: 'error',
+            content: msg.content,
+          });
+        }
+      };
+
+      // Wait for execution to complete
+      await future.done;
+
+      return {
+        success: true,
+        outputs,
+        executionCount,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
 }

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

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+
+/**
+ * Tool definition for executing code directly in kernel
+ *
+ * @module tools/definitions/executeCode
+ */
+
+import type { ToolDefinition } from '../core/schema';
+
+/**
+ * Tool definition for executing code directly in the kernel
+ *
+ * Executes code without creating or modifying blocks in the document.
+ */
+export const executeCodeTool: ToolDefinition = {
+  name: 'datalayer_executeCode_lexical',
+  displayName: 'Execute Code in Kernel (Lexical)',
+  toolReferenceName: 'executeCode',
+  description:
+    'Executes code directly in the Jupyter kernel without creating or modifying blocks in the Lexical document. Useful for variable inspection, environment setup, background tasks, and tool introspection. Returns execution outputs including streams, results, and errors.',
+
+  parameters: {
+    type: 'object' as const,
+    properties: {
+      code: {
+        type: 'string',
+        description: 'Python code to execute in the kernel',
+      },
+      storeHistory: {
+        type: 'boolean',
+        description:
+          'Whether to store this execution in kernel history (default: false). Set to true to make this code accessible via In[n].',
+      },
+      silent: {
+        type: 'boolean',
+        description:
+          'Silent execution - no output displayed (default: false). Useful for background tasks.',
+      },
+      stopOnError: {
+        type: 'boolean',
+        description:
+          'Stop execution if an error occurs (default: true). Set to false to continue execution even on errors.',
+      },
+    },
+    required: ['code'],
+  },
+
+  operation: 'executeCode',
+
+  config: {
+    confirmationMessage: (params: { code: string }) =>
+      `Execute code: ${params.code.substring(0, 50)}${params.code.length > 50 ? '...' : ''}?`,
+    invocationMessage: () => 'Executing code in kernel',
+    requiresConfirmation: false,
+    canBeReferencedInPrompt: true,
+    priority: 'high',
+  },
+
+  tags: ['lexical', 'kernel', 'execute', 'code', 'inspection'],
+};

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

@@ -21,3 +21,4 @@ export * from './readAllBlocks';
 export * from './runBlock';
 export * from './runAllBlocks';
 export * from './listAvailableBlocks';
+export * from './executeCode';

packages/lexical/src/tools/index.ts

@@ -22,6 +22,7 @@ import { readAllBlocksTool } from './definitions/readAllBlocks';
 import { runBlockTool } from './definitions/runBlock';
 import { runAllBlocksTool } from './definitions/runAllBlocks';
 import { listAvailableBlocksTool } from './definitions/listAvailableBlocks';
+import { executeCodeTool } from './definitions/executeCode';
 
 // Import all operations
 import { insertBlockOperation } from './operations/insertBlock';
@@ -33,6 +34,7 @@ import { readAllBlocksOperation } from './operations/readAllBlocks';
 import { runBlockOperation } from './operations/runBlock';
 import { runAllBlocksOperation } from './operations/runAllBlocks';
 import { listAvailableBlocksOperation } from './operations/listAvailableBlocks';
+import { executeCodeOperation } from './operations/executeCode';
 
 // Import types
 import type { ToolDefinition } from './core/schema';
@@ -51,6 +53,7 @@ export const lexicalToolDefinitions: ToolDefinition[] = [
   runBlockTool,
   runAllBlocksTool,
   listAvailableBlocksTool,
+  executeCodeTool,
 ];
 
 /**
@@ -70,6 +73,7 @@ export const lexicalToolOperations: Record<
   runBlock: runBlockOperation,
   runAllBlocks: runAllBlocksOperation,
   listAvailableBlocks: listAvailableBlocksOperation,
+  executeCode: executeCodeOperation,
 };
 
 /**
@@ -92,5 +96,6 @@ export * from './operations/readAllBlocks';
 export * from './operations/runBlock';
 export * from './operations/runAllBlocks';
 export * from './operations/listAvailableBlocks';
+export * from './operations/executeCode';
 export * from '../state';
 export * from './utils';

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

@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+
+/**
+ * Platform-agnostic code execution operation for Lexical documents.
+ * Executes code directly in the kernel without creating or modifying blocks.
+ *
+ * @module tools/operations/executeCode
+ */
+
+import type {
+  ToolOperation,
+  LexicalExecutionContext,
+} from '../core/interfaces';
+import { formatResponse } from '../core/formatter';
+
+/**
+ * Parameters for executeCode operation.
+ */
+export interface ExecuteCodeParams {
+  /** Code to execute */
+  code: string;
+
+  /** Whether to store in kernel history (default: false) */
+  storeHistory?: boolean;
+
+  /** Silent execution - no output displayed (default: false) */
+  silent?: boolean;
+
+  /** Stop execution on error (default: true) */
+  stopOnError?: boolean;
+}
+
+/**
+ * Validates ExecuteCodeParams at runtime.
+ */
+function isExecuteCodeParams(params: unknown): params is ExecuteCodeParams {
+  if (typeof params !== 'object' || params === null) {
+    return false;
+  }
+
+  const p = params as Record<string, unknown>;
+
+  // code is required and must be a string
+  if (typeof p.code !== 'string') {
+    return false;
+  }
+
+  // Optional boolean fields
+  if (p.storeHistory !== undefined && typeof p.storeHistory !== 'boolean') {
+    return false;
+  }
+  if (p.silent !== undefined && typeof p.silent !== 'boolean') {
+    return false;
+  }
+  if (p.stopOnError !== undefined && typeof p.stopOnError !== 'boolean') {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Result from executeCode operation.
+ */
+export interface ExecuteCodeResult {
+  success: boolean;
+  /** Execution outputs (streams, results, errors) */
+  outputs?: Array<{
+    type: 'stream' | 'execute_result' | 'display_data' | 'error';
+    content: unknown;
+  }>;
+  /** Error message if execution failed */
+  error?: string;
+  /** Execution count (if stored in history) */
+  executionCount?: number;
+}
+
+/**
+ * Executes code directly in the kernel without creating a block.
+ *
+ * This is useful for:
+ * - Variable inspection
+ * - Environment setup
+ * - Background tasks
+ * - Tool introspection
+ */
+export const executeCodeOperation: ToolOperation<
+  ExecuteCodeParams,
+  ExecuteCodeResult
+> = {
+  name: 'executeCode',
+
+  async execute(
+    params: unknown,
+    context: LexicalExecutionContext,
+  ): Promise<ExecuteCodeResult> {
+    // Validate params using type guard
+    if (!isExecuteCodeParams(params)) {
+      throw new Error(
+        `Invalid parameters for executeCode. Expected { code: string, storeHistory?: boolean, silent?: boolean, stopOnError?: boolean }. ` +
+          `Received: ${JSON.stringify(params)}`,
+      );
+    }
+
+    const { lexicalId } = context;
+
+    if (!lexicalId) {
+      return formatResponse(
+        {
+          success: false,
+          error: 'Lexical ID is required for this operation.',
+        },
+        context.format,
+      ) as ExecuteCodeResult;
+    }
+
+    // Ensure executeCommand is available
+    if (!context.executeCommand) {
+      throw new Error(
+        'executeCommand callback is required for executeCode operation. ' +
+          'This should be provided by the platform adapter.',
+      );
+    }
+
+    try {
+      // Call internal command to execute code directly in kernel
+      const result = await context.executeCommand<ExecuteCodeResult>(
+        'lexical.executeCode',
+        {
+          lexicalId,
+          ...params,
+        },
+      );
+
+      return formatResponse(result, context.format) as ExecuteCodeResult;
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to execute code: ${errorMessage}`);
+    }
+  },
+};