@datalayer/jupyter-react 1.1.8 → 1.2.0

package/lib/tools/definitions/executeCode.js

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { executeCodeParamsSchema } from '../schemas/executeCode';
+export const executeCodeTool = {
+    name: 'datalayer_executeCode',
+    displayName: 'Execute Code in Kernel',
+    toolReferenceName: 'executeCode',
+    description: 'Execute code directly in the kernel (not saved to notebook) on the current activated notebook.\n\n' +
+        'Recommended to use in following cases:\n' +
+        '1. Execute Jupyter magic commands (e.g., %timeit, %pip install xxx)\n' +
+        '2. Performance profiling and debugging\n' +
+        '3. View intermediate variable values (e.g., print(xxx), df.head())\n' +
+        "4. Temporary calculations and quick tests (e.g., np.mean(df['xxx']))\n" +
+        '5. Execute Shell commands in Jupyter server (e.g., !git xxx)\n\n' +
+        'Under no circumstances should you use this tool to:\n' +
+        '1. Import new modules or perform variable assignments that affect subsequent Notebook execution\n' +
+        "2. Execute dangerous code that may harm the Jupyter server or the user's data without permission",
+    parameters: zodToToolParameters(executeCodeParamsSchema),
+    operation: 'executeCode',
+    config: {
+        confirmationMessage: (params) => `Execute code: ${params.code.substring(0, 50)}${params.code.length > 50 ? '...' : ''}?`,
+        invocationMessage: () => 'Executing code in kernel',
+        requiresConfirmation: false,
+        canBeReferencedInPrompt: true,
+        priority: 'high',
+    },
+    tags: ['kernel', 'notebook', 'execute', 'code', 'inspection', 'magic'],
+};
+//# sourceMappingURL=executeCode.js.map

package/lib/tools/definitions/executeCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executeCode.js","sourceRoot":"","sources":["../../../src/tools/definitions/executeCode.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,MAAM,CAAC,MAAM,eAAe,GAAmB;IAC7C,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,wBAAwB;IACrC,iBAAiB,EAAE,aAAa;IAChC,WAAW,EACT,oGAAoG;QACpG,0CAA0C;QAC1C,uEAAuE;QACvE,0CAA0C;QAC1C,sEAAsE;QACtE,wEAAwE;QACxE,kEAAkE;QAClE,uDAAuD;QACvD,mGAAmG;QACnG,kGAAkG;IAEpG,UAAU,EAAE,mBAAmB,CAAC,uBAAuB,CAAC;IAExD,SAAS,EAAE,aAAa;IAExB,MAAM,EAAE;QACN,mBAAmB,EAAE,CAAC,MAAwB,EAAE,EAAE,CAChD,iBAAiB,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG;QACzF,iBAAiB,EAAE,GAAG,EAAE,CAAC,0BAA0B;QACnD,oBAAoB,EAAE,KAAK;QAC3B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,MAAM;KACjB;IAED,IAAI,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC;CACvE,CAAC"}

package/lib/tools/definitions/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tool definitions (schemas) for notebook operations.
+ *
+ * @module tools/definitions
+ */
+export * from './insertCell';
+export * from './deleteCell';
+export * from './updateCell';
+export * from './readCell';
+export * from './readAllCells';
+export * from './runCell';
+export * from './executeCode';

package/lib/tools/definitions/index.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+/**
+ * Tool definitions (schemas) for notebook operations.
+ *
+ * @module tools/definitions
+ */
+export * from './insertCell';
+export * from './deleteCell';
+export * from './updateCell';
+export * from './readCell';
+export * from './readAllCells';
+export * from './runCell';
+export * from './executeCode';
+//# sourceMappingURL=index.js.map

package/lib/tools/definitions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/lib/tools/definitions/insertCell.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Insert cell tool definition.
+ *
+ * @module tools/definitions/insertCell
+ */
+import type { ToolDefinition } from '../core/schema';
+export declare const insertCellTool: ToolDefinition;

package/lib/tools/definitions/insertCell.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { insertCellParamsSchema } from '../schemas/insertCell';
+export const insertCellTool = {
+    name: 'datalayer_insertCell',
+    displayName: 'Insert Notebook Cell',
+    toolReferenceName: 'insertCell',
+    description: 'IMPORTANT: Call readAllCells first to see the current notebook structure and determine the correct insertion point. Then, insert a code or markdown cell into a Jupyter notebook at a specified position or at the end',
+    parameters: zodToToolParameters(insertCellParamsSchema),
+    operation: 'insertCell',
+    config: {
+        confirmationMessage: (params) => `Insert ${params.type} cell into notebook?\n\n${params.source}`,
+        invocationMessage: (params) => `Inserting ${params.type} cell into notebook`,
+        requiresConfirmation: true,
+        canBeReferencedInPrompt: true,
+        priority: 'high',
+    },
+    tags: ['cell', 'notebook', 'manipulation', 'create'],
+};
+//# sourceMappingURL=insertCell.js.map

package/lib/tools/definitions/insertCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"insertCell.js","sourceRoot":"","sources":["../../../src/tools/definitions/insertCell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,MAAM,CAAC,MAAM,cAAc,GAAmB;IAC5C,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE,sBAAsB;IACnC,iBAAiB,EAAE,YAAY;IAC/B,WAAW,EACT,wNAAwN;IAE1N,UAAU,EAAE,mBAAmB,CAAC,sBAAsB,CAAC;IAEvD,SAAS,EAAE,YAAY;IAEvB,MAAM,EAAE;QACN,mBAAmB,EAAE,CAAC,MAAwC,EAAE,EAAE,CAChE,UAAU,MAAM,CAAC,IAAI,2BAA2B,MAAM,CAAC,MAAM,EAAE;QACjE,iBAAiB,EAAE,CAAC,MAAwB,EAAE,EAAE,CAC9C,aAAa,MAAM,CAAC,IAAI,qBAAqB;QAC/C,oBAAoB,EAAE,IAAI;QAC1B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,MAAM;KACjB;IAED,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC;CACrD,CAAC"}

package/lib/tools/definitions/readAllCells.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read all cells tool definition.
+ *
+ * @module tools/definitions/readAllCells
+ */
+import type { ToolDefinition } from '../core/schema';
+export declare const readAllCellsTool: ToolDefinition;

package/lib/tools/definitions/readAllCells.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { readAllCellsParamsSchema } from '../schemas/readAllCells';
+export const readAllCellsTool = {
+    name: 'datalayer_readAllCells',
+    displayName: 'Read All Notebook Cells',
+    toolReferenceName: 'readAllCells',
+    description: "Read all cells from the Jupyter notebook. Supports two response formats: 'brief' (default) returns index, type, and 40-char content preview for structure queries and counting cells; 'detailed' returns full content with source, execution_count, and outputs. Use brief when you need to see notebook structure, count cells, or quickly scan content. Use detailed when you need to read full cell content or outputs. Brief format preview shows first 40 characters of cell source. Returns array of cells with: index (cell position), type (code, markdown, raw), preview (brief only), and optionally source/execution_count/outputs (detailed only). Works on active notebook.",
+    parameters: zodToToolParameters(readAllCellsParamsSchema),
+    operation: 'readAllCells',
+    config: {
+        confirmationMessage: () => 'Read all cells from notebook?',
+        invocationMessage: () => 'Reading all cells',
+        requiresConfirmation: false,
+        canBeReferencedInPrompt: true,
+        priority: 'high',
+    },
+    tags: ['cell', 'notebook', 'read', 'inspect', 'all'],
+};
+//# sourceMappingURL=readAllCells.js.map

package/lib/tools/definitions/readAllCells.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readAllCells.js","sourceRoot":"","sources":["../../../src/tools/definitions/readAllCells.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,MAAM,CAAC,MAAM,gBAAgB,GAAmB;IAC9C,IAAI,EAAE,wBAAwB;IAC9B,WAAW,EAAE,yBAAyB;IACtC,iBAAiB,EAAE,cAAc;IACjC,WAAW,EACT,0pBAA0pB;IAE5pB,UAAU,EAAE,mBAAmB,CAAC,wBAAwB,CAAC;IAEzD,SAAS,EAAE,cAAc;IAEzB,MAAM,EAAE;QACN,mBAAmB,EAAE,GAAG,EAAE,CAAC,+BAA+B;QAC1D,iBAAiB,EAAE,GAAG,EAAE,CAAC,mBAAmB;QAC5C,oBAAoB,EAAE,KAAK;QAC3B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,MAAM;KACjB;IAED,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,CAAC;CACrD,CAAC"}

package/lib/tools/definitions/readCell.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Read cell tool definition.
+ *
+ * @module tools/definitions/readCell
+ */
+import type { ToolDefinition } from '../core/schema';
+export declare const readCellTool: ToolDefinition;

package/lib/tools/definitions/readCell.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { readCellParamsSchema } from '../schemas/readCell';
+export const readCellTool = {
+    name: 'datalayer_readCell',
+    displayName: 'Read Notebook Cell',
+    toolReferenceName: 'readCell',
+    description: 'Reads a specific cell from a Jupyter notebook by index, including source code and outputs',
+    parameters: zodToToolParameters(readCellParamsSchema),
+    operation: 'readCell',
+    config: {
+        confirmationMessage: (params) => `Read cell at index ${params.index}?`,
+        invocationMessage: (params) => `Reading cell ${params.index}`,
+        requiresConfirmation: false,
+        canBeReferencedInPrompt: true,
+        priority: 'high',
+    },
+    tags: ['cell', 'notebook', 'read', 'inspect'],
+};
+//# sourceMappingURL=readCell.js.map

package/lib/tools/definitions/readCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readCell.js","sourceRoot":"","sources":["../../../src/tools/definitions/readCell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D,MAAM,CAAC,MAAM,YAAY,GAAmB;IAC1C,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,oBAAoB;IACjC,iBAAiB,EAAE,UAAU;IAC7B,WAAW,EACT,2FAA2F;IAE7F,UAAU,EAAE,mBAAmB,CAAC,oBAAoB,CAAC;IAErD,SAAS,EAAE,UAAU;IAErB,MAAM,EAAE;QACN,mBAAmB,EAAE,CAAC,MAAyB,EAAE,EAAE,CACjD,sBAAsB,MAAM,CAAC,KAAK,GAAG;QACvC,iBAAiB,EAAE,CAAC,MAAyB,EAAE,EAAE,CAC/C,gBAAgB,MAAM,CAAC,KAAK,EAAE;QAChC,oBAAoB,EAAE,KAAK;QAC3B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,MAAM;KACjB;IAED,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,CAAC;CAC9C,CAAC"}

package/lib/tools/definitions/runCell.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Run cell tool definition.
+ *
+ * @module tools/definitions/runCell
+ */
+import type { ToolDefinition } from '../core/schema';
+export declare const runCellTool: ToolDefinition;

package/lib/tools/definitions/runCell.js

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { runCellParamsSchema } from '../schemas/runCell';
+export const runCellTool = {
+    name: 'datalayer_runCell',
+    displayName: 'Run Notebook Cell',
+    toolReferenceName: 'runCell',
+    description: 'Runs a code cell in a Jupyter notebook and returns its outputs with execution metadata. ' +
+        'Supports timeout and streaming progress updates. ' +
+        'Returns execution_count, outputs, and elapsed_time. ' +
+        'If no index is provided, runs the currently active cell.',
+    parameters: zodToToolParameters(runCellParamsSchema),
+    operation: 'runCell',
+    config: {
+        confirmationMessage: (params) => params.index !== undefined
+            ? `Run cell at index ${params.index}?`
+            : 'Run cell?',
+        invocationMessage: (params) => params.index !== undefined
+            ? `Running cell ${params.index}${params.timeoutSeconds ? ` (timeout: ${params.timeoutSeconds}s)` : ''}`
+            : `Running cell${params.timeoutSeconds ? ` (timeout: ${params.timeoutSeconds}s)` : ''}`,
+        requiresConfirmation: false,
+        canBeReferencedInPrompt: true,
+        priority: 'high',
+    },
+    tags: ['cell', 'notebook', 'execute', 'run', 'outputs'],
+};
+//# sourceMappingURL=runCell.js.map

package/lib/tools/definitions/runCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runCell.js","sourceRoot":"","sources":["../../../src/tools/definitions/runCell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD,MAAM,CAAC,MAAM,WAAW,GAAmB;IACzC,IAAI,EAAE,mBAAmB;IACzB,WAAW,EAAE,mBAAmB;IAChC,iBAAiB,EAAE,SAAS;IAC5B,WAAW,EACT,0FAA0F;QAC1F,mDAAmD;QACnD,sDAAsD;QACtD,0DAA0D;IAE5D,UAAU,EAAE,mBAAmB,CAAC,mBAAmB,CAAC;IAEpD,SAAS,EAAE,SAAS;IAEpB,MAAM,EAAE;QACN,mBAAmB,EAAE,CAAC,MAA0B,EAAE,EAAE,CAClD,MAAM,CAAC,KAAK,KAAK,SAAS;YACxB,CAAC,CAAC,qBAAqB,MAAM,CAAC,KAAK,GAAG;YACtC,CAAC,CAAC,WAAW;QACjB,iBAAiB,EAAE,CAAC,MAAmD,EAAE,EAAE,CACzE,MAAM,CAAC,KAAK,KAAK,SAAS;YACxB,CAAC,CAAC,gBAAgB,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,cAAc,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;YACvG,CAAC,CAAC,eAAe,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,cAAc,MAAM,CAAC,cAAc,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QAC3F,oBAAoB,EAAE,KAAK;QAC3B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,MAAM;KACjB;IAED,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,CAAC;CACxD,CAAC"}

package/lib/tools/definitions/updateCell.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Update cell tool definition.
+ *
+ * @module tools/definitions/updateCell
+ */
+import type { ToolDefinition } from '../core/schema';
+export declare const updateCellTool: ToolDefinition;

package/lib/tools/definitions/updateCell.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { zodToToolParameters } from '../core/zodUtils';
+import { updateCellParamsSchema } from '../schemas/updateCell';
+export const updateCellTool = {
+    name: 'datalayer_updateCell',
+    displayName: 'Update Notebook Cell',
+    toolReferenceName: 'updateCell',
+    description: "Updates (overwrites) a cell's source code at the specified index. Does NOT execute the cell.",
+    parameters: zodToToolParameters(updateCellParamsSchema),
+    operation: 'updateCell',
+    config: {
+        confirmationMessage: (params) => `Update cell at index ${params.index}?\n\n${params.source}`,
+        invocationMessage: (params) => `Updating cell ${params.index}`,
+        requiresConfirmation: false,
+        canBeReferencedInPrompt: true,
+        priority: 'medium',
+    },
+    tags: ['cell', 'notebook', 'manipulation', 'update'],
+};
+//# sourceMappingURL=updateCell.js.map

package/lib/tools/definitions/updateCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateCell.js","sourceRoot":"","sources":["../../../src/tools/definitions/updateCell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,MAAM,CAAC,MAAM,cAAc,GAAmB;IAC5C,IAAI,EAAE,sBAAsB;IAC5B,WAAW,EAAE,sBAAsB;IACnC,iBAAiB,EAAE,YAAY;IAC/B,WAAW,EACT,8FAA8F;IAEhG,UAAU,EAAE,mBAAmB,CAAC,sBAAsB,CAAC;IAEvD,SAAS,EAAE,YAAY;IAEvB,MAAM,EAAE;QACN,mBAAmB,EAAE,CAAC,MAAyC,EAAE,EAAE,CACjE,wBAAwB,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,MAAM,EAAE;QAC7D,iBAAiB,EAAE,CAAC,MAAyB,EAAE,EAAE,CAC/C,iBAAiB,MAAM,CAAC,KAAK,EAAE;QACjC,oBAAoB,EAAE,KAAK;QAC3B,uBAAuB,EAAE,IAAI;QAC7B,QAAQ,EAAE,QAAQ;KACnB;IAED,IAAI,EAAE,CAAC,MAAM,EAAE,UAAU,EAAE,cAAc,EAAE,QAAQ,CAAC;CACrD,CAAC"}

package/lib/tools/index.d.ts

@@ -0,0 +1,20 @@
+import type { ToolDefinition } from './core/schema';
+import type { ToolOperation } from './core/interfaces';
+/**
+ * Array of all notebook tool definitions
+ */
+export declare const notebookToolDefinitions: ToolDefinition[];
+/**
+ * Registry of all notebook tool operations
+ * Maps operation names to their implementations
+ */
+export declare const notebookToolOperations: Record<string, ToolOperation<unknown, unknown>>;
+/**
+ * Complete notebook tools bundle for easy iteration and registration
+ */
+export declare const notebookTools: {
+    definitions: ToolDefinition<unknown>[];
+    operations: Record<string, ToolOperation<unknown, unknown>>;
+};
+export * from './core';
+export * from './definitions';

package/lib/tools/index.js

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+/**
+ * Platform-agnostic notebook tools.
+ *
+ * @module tools
+ */
+// Import all tool definitions
+import { insertCellTool } from './definitions/insertCell';
+import { deleteCellTool } from './definitions/deleteCell';
+import { updateCellTool } from './definitions/updateCell';
+import { readCellTool } from './definitions/readCell';
+import { readAllCellsTool } from './definitions/readAllCells';
+import { runCellTool } from './definitions/runCell';
+import { executeCodeTool } from './definitions/executeCode';
+// Import all operations
+import { insertCellOperation } from './operations/insertCell';
+import { deleteCellOperation } from './operations/deleteCell';
+import { updateCellOperation } from './operations/updateCell';
+import { readCellOperation } from './operations/readCell';
+import { readAllCellsOperation } from './operations/readAllCells';
+import { runCellOperation } from './operations/runCell';
+import { executeCodeOperation } from './operations/executeCode';
+/**
+ * Array of all notebook tool definitions
+ */
+export const notebookToolDefinitions = [
+    insertCellTool,
+    deleteCellTool,
+    updateCellTool,
+    readCellTool,
+    readAllCellsTool,
+    runCellTool,
+    executeCodeTool,
+];
+/**
+ * Registry of all notebook tool operations
+ * Maps operation names to their implementations
+ */
+export const notebookToolOperations = {
+    insertCell: insertCellOperation,
+    deleteCell: deleteCellOperation,
+    updateCell: updateCellOperation,
+    readCell: readCellOperation,
+    readAllCells: readAllCellsOperation,
+    runCell: runCellOperation,
+    executeCode: executeCodeOperation,
+};
+/**
+ * Complete notebook tools bundle for easy iteration and registration
+ */
+export const notebookTools = {
+    definitions: notebookToolDefinitions,
+    operations: notebookToolOperations,
+};
+// Re-export everything for convenience
+export * from './core';
+export * from './definitions';
+//# sourceMappingURL=index.js.map

package/lib/tools/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AAEH,8BAA8B;AAC9B,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,wBAAwB;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAMhE;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAqB;IACvD,cAAc;IACd,cAAc;IACd,cAAc;IACd,YAAY;IACZ,gBAAgB;IAChB,WAAW;IACX,eAAe;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAG/B;IACF,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE,mBAAmB;IAC/B,QAAQ,EAAE,iBAAiB;IAC3B,YAAY,EAAE,qBAAqB;IACnC,OAAO,EAAE,gBAAgB;IACzB,WAAW,EAAE,oBAAoB;CAClC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,WAAW,EAAE,uBAAuB;IACpC,UAAU,EAAE,sBAAsB;CACnC,CAAC;AAEF,uCAAuC;AACvC,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC"}

package/lib/tools/operations/deleteCell.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Platform-agnostic cell deletion operation.
+ *
+ * @module tools/operations/deleteCell
+ */
+import type { ToolOperation } from '../core/interfaces';
+import { type DeleteCellParams } from '../schemas/deleteCell';
+/**
+ * Information about a deleted cell.
+ */
+export interface DeletedCellInfo {
+    /** Original index of the deleted cell */
+    index: number;
+    /** Cell type (code, markdown, raw) */
+    type: string;
+    /** Cell source content */
+    source: string;
+}
+/**
+ * Result from deleteCell operation.
+ */
+export interface DeleteCellResult {
+    success: boolean;
+    deletedCells: DeletedCellInfo[];
+    message: string;
+}
+/**
+ * Deletes one or more cells from a notebook at the specified indices.
+ *
+ * Cells are deleted in reverse order (highest index first) to prevent
+ * index shifting issues during multi-cell deletion. This matches the
+ * behavior of the Jupyter MCP Server.
+ *
+ * @example
+ * ```typescript
+ * // Delete single cell
+ * await deleteCellOperation.execute(
+ *   { indices: [2] },
+ *   { documentId: "file:///path/to/notebook.ipynb", executor }
+ * );
+ *
+ * // Delete multiple cells
+ * await deleteCellOperation.execute(
+ *   { indices: [1, 3, 5] },
+ *   { documentId: "file:///path/to/notebook.ipynb", executor }
+ * );
+ * ```
+ */
+export declare const deleteCellOperation: ToolOperation<DeleteCellParams, DeleteCellResult>;

package/lib/tools/operations/deleteCell.js

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { readAllCellsOperation } from './readAllCells';
+import { validateWithZod } from '../core/zodUtils';
+import { deleteCellParamsSchema, } from '../schemas/deleteCell';
+/**
+ * Deletes one or more cells from a notebook at the specified indices.
+ *
+ * Cells are deleted in reverse order (highest index first) to prevent
+ * index shifting issues during multi-cell deletion. This matches the
+ * behavior of the Jupyter MCP Server.
+ *
+ * @example
+ * ```typescript
+ * // Delete single cell
+ * await deleteCellOperation.execute(
+ *   { indices: [2] },
+ *   { documentId: "file:///path/to/notebook.ipynb", executor }
+ * );
+ *
+ * // Delete multiple cells
+ * await deleteCellOperation.execute(
+ *   { indices: [1, 3, 5] },
+ *   { documentId: "file:///path/to/notebook.ipynb", executor }
+ * );
+ * ```
+ */
+export const deleteCellOperation = {
+    name: 'deleteCell',
+    async execute(params, context) {
+        // Validate params using Zod schema
+        const { indices } = validateWithZod(deleteCellParamsSchema, params, this.name);
+        const { documentId } = context;
+        if (!documentId) {
+            throw new Error('Document ID is required for deleteCell operation. ' +
+                'Ensure the tool execution context includes a valid documentId.');
+        }
+        // Ensure executor is available
+        if (!context.executor) {
+            throw new Error('Executor is required for deleteCell operation. ' +
+                'This should be provided by the platform (DefaultExecutor, BridgeExecutor, etc.)');
+        }
+        try {
+            // First, read all cells to get current state and validate indices
+            // Request detailed format to get full source for deletion confirmation
+            const cellsResult = await readAllCellsOperation.execute({ format: 'detailed' }, context);
+            if (!cellsResult.success || !cellsResult.cells) {
+                throw new Error('Failed to read cells for bounds validation');
+            }
+            const cellCount = cellsResult.cellCount || cellsResult.cells.length;
+            const cells = cellsResult.cells;
+            // Validate ALL indices are in range (match Jupyter MCP Server error format)
+            for (const index of indices) {
+                if (index < 0 || index >= cellCount) {
+                    throw new Error(`Cell index ${index} is out of range. Notebook has ${cellCount} cells.`);
+                }
+            }
+            // Sort indices in REVERSE order (highest to lowest) to prevent index shifting
+            // This matches the Jupyter MCP Server behavior
+            const sortedIndices = [...indices].sort((a, b) => b - a);
+            // Store information about cells before deletion
+            const deletedCells = [];
+            // Delete each cell in reverse order
+            for (const index of sortedIndices) {
+                // Store cell info before deletion (from original read)
+                const cell = cells[index];
+                // Execute deletion via executor
+                await context.executor.execute(this.name, {
+                    index,
+                });
+                // Track deletion with original index
+                deletedCells.push({
+                    index,
+                    type: cell.type,
+                    source: cell.source,
+                });
+            }
+            // Format message similar to Jupyter MCP Server
+            const message = deletedCells
+                .map(cell => {
+                return (`Deleted cell at index ${cell.index}:\n` +
+                    `Type: ${cell.type}\n` +
+                    `----------------------------------------`);
+            })
+                .join('\n\n');
+            // Return success result
+            return {
+                success: true,
+                deletedCells: deletedCells.reverse(), // Reverse to show in original order
+                message,
+            };
+        }
+        catch (error) {
+            // Convert error to descriptive error
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to delete cell(s): ${errorMessage}`);
+        }
+    },
+};
+//# sourceMappingURL=deleteCell.js.map

package/lib/tools/operations/deleteCell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleteCell.js","sourceRoot":"","sources":["../../../src/tools/operations/deleteCell.ts"],"names":[],"mappings":"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"}

package/lib/tools/operations/executeCode.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Platform-agnostic code execution operation.
+ * Executes code directly in the kernel without creating or modifying cells.
+ *
+ * @module tools/operations/executeCode
+ */
+import type { ToolOperation } from '../core/interfaces';
+import { type ExecuteCodeParams } from '../schemas/executeCode';
+/**
+ * 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 cell.
+ *
+ * This is useful for:
+ * - Variable inspection
+ * - Environment setup
+ * - Background tasks
+ * - Tool introspection
+ */
+export declare const executeCodeOperation: ToolOperation<ExecuteCodeParams, ExecuteCodeResult>;

package/lib/tools/operations/executeCode.js

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2021-2023 Datalayer, Inc.
+ *
+ * MIT License
+ */
+import { validateWithZod } from '../core/zodUtils';
+import { executeCodeParamsSchema, } from '../schemas/executeCode';
+/**
+ * Executes code directly in the kernel without creating a cell.
+ *
+ * This is useful for:
+ * - Variable inspection
+ * - Environment setup
+ * - Background tasks
+ * - Tool introspection
+ */
+export const executeCodeOperation = {
+    name: 'executeCode',
+    async execute(params, context) {
+        // Validate params using Zod schema
+        validateWithZod(executeCodeParamsSchema, params, this.name);
+        const { documentId } = context;
+        if (!documentId) {
+            return {
+                success: false,
+                error: 'Document ID is required for this operation.',
+            };
+        }
+        // Ensure executor is available
+        if (!context.executor) {
+            throw new Error('Executor is required for executeCode operation. ' +
+                'This should be provided by the platform (DefaultExecutor, BridgeExecutor, etc.)');
+        }
+        try {
+            // Call executor (uses this.name for DRY principle)
+            const result = await context.executor.execute(this.name, params);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to execute code: ${errorMessage}`);
+        }
+    },
+};
+//# sourceMappingURL=executeCode.js.map

package/lib/tools/operations/executeCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executeCode.js","sourceRoot":"","sources":["../../../src/tools/operations/executeCode.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAUH,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EACL,uBAAuB,GAExB,MAAM,wBAAwB,CAAC;AAkBhC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAG7B;IACF,IAAI,EAAE,aAAa;IAEnB,KAAK,CAAC,OAAO,CACX,MAAe,EACf,OAA6B;QAE7B,mCAAmC;QACnC,eAAe,CAAC,uBAAuB,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAE5D,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QAE/B,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,6CAA6C;aACrD,CAAC;QACJ,CAAC;QAED,+BAA+B;QAC/B,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CACb,kDAAkD;gBAChD,iFAAiF,CACpF,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,mDAAmD;YACnD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAEjE,OAAO,MAA2B,CAAC;QACrC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAChB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACzD,MAAM,IAAI,KAAK,CAAC,2BAA2B,YAAY,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;CACF,CAAC"}

package/lib/tools/operations/insertCell.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Platform-agnostic cell insertion operation.
+ *
+ * @module tools/operations/insertCell
+ */
+import type { ToolOperation } from '../core/interfaces';
+import { type InsertCellParams } from '../schemas/insertCell';
+/**
+ * Result from insertCell operation.
+ */
+export interface InsertCellResult {
+    success: boolean;
+    index: number;
+    message: string;
+}
+/**
+ * Inserts a cell into a notebook at the specified position.
+ *
+ * @example
+ * ```typescript
+ * await insertCellOperation.execute(
+ *   { type: 'code', source: 'print("Hello")' },
+ *   { documentId: 'file:///path/to/notebook.ipynb', executor }
+ * );
+ * ```
+ */
+export declare const insertCellOperation: ToolOperation<InsertCellParams, InsertCellResult>;