Enhance `delete_cell` to Support Safer Bulk Deletion

[ChengJiale150]

Problem Overview

When needing to delete multiple cells at once (e.g., deleting an entire module or code block), the current delete_cell tool has a risk of incorrect deletion due to index shifting.

Problem Details

Background

The delete_cell tool is currently designed to delete a single cell, but in practical applications, users often need to delete multiple cells. Because the deletion operation itself changes the index position of the remaining cells in the Notebook (index shifting), if the LLM deletes cells in ascending order, it will cause serious problems.

Specific Problem Example

Assume a Notebook has the following cell structure:

Index 0: import pandas as pd
Index 1: import numpy as np
Index 2: # Module A - To be deleted
Index 3: x = 1
Index 4: y = 2
Index 5: # Module B - To be deleted
Index 6: z = 3
Index 7: print(x, y, z)

The user wants to delete the cells related to Module A and Module B (Index 2, 3, 4, 5).

Incorrect deletion order (ascending):

1. Delete Index 2: Successfully deletes "# Module A", the remaining cells automatically shift forward.
2. Delete Index 3: The intention is to delete x = 1, but due to index shifting, the content of the original Index 4 is actually deleted (y = 2).
3. Delete Index 4: The intention is to delete the remaining content of Module B, but the wrong cell is actually deleted.
4. Delete Index 5: May accidentally delete the final print statement.

Result: The finally deleted cells do not match the expectation, and user data is unpredictably corrupted.

Current Attempted Solutions and Their Limitations

A warning has been added to the tool description:

"When deleting many cells, MUST delete them in descending order of their index to avoid index shifting."

At the same time, the delete operation will also return the content of the deleted cell for verification.

But the problems with these solutions are:

• ❌ The LLM will not necessarily follow the text prompts completely.
• ❌ Relying on the LLM's understanding ability is uncertain.
• ❌ Cannot fundamentally prevent accidental deletion.

Solution

Core Idea

Shift the responsibility from prompt guidance to the tool implementation itself, letting the tool internally handle the correct order and logic for bulk deletion.

Specific Improvement Plan

1. Modify the Interface Signature

Current:

async def delete_cell(
    cell_index: Annotated[int, Field(description="Index of the cell to delete (0-based)", ge=0)],
) -> Annotated[str, Field(description="Success message and the cell source of deleted cell")]:

Proposed:

async def delete_cell(
    cell_indices: Annotated[list[int], Field(description="List of cell indices to delete (0-based)",min_items=1)],
    include_source: Annotated[bool, Field(description="Whether to include the source of deleted cells")] = True,
) -> Annotated[str, Field(description="Success message with list of deleted cells and their source (if include_source=True)")]

2. Tool Implementation Improvements

Improvement Points:

1. Automatic Descending Sort: Receive a list of indices in any order, and internally sort them in descending order for processing.
2. Index Validation: Verify that all indices are valid and within range.
3. Traceability: Record detailed information about the deletion operation for auditing and recovery.

Advantages

Aspect	Current Solution	Improved Solution
Reliability	Relies on LLM's understanding	Internally handled, 100% reliable
User Friendliness	Requires user to manually sort in descending order	Automatically handles any order
Error Risk	High (prone to accidental deletion)	Low (prevents index shifting)
Traceability	Limited	Detailed deletion logs and return information
Performance	N requests	1 request to complete N deletions