agent's nbformat write failed: lost the cell tags papermill needs, parameters mi

Not specified by the original author.

TL;DR

Papermill finds its parameters cell by the parameters tag, so any agent transformation that rebuilds cells without copying metadata.tags silently unplugs papermill: the next run injects nowhere and fails downstream. Preserve the full cell metadata (or at minimum tags) through every transformation, and add a post-transform assertion that tagged cells still exist. Tags are load-bearing; treat them as such.

agent's nbformat write failed: lost the cell tags papermill needs, parameters missing

Use this when

• Papermill stops injecting after an agent rewrites the notebook.
• The rewritten notebook has no parameters tag.
• The agent rebuilds cells (split, merge, clean).

Not for this skill when

• The tag was never there. Tag the cell.
• Papermill injects but values are wrong. That is a typing issue.

Steps

1. Confirm the loss: compare tags before and after the transform. Verify: the parameters tag is gone.
2. Fix the transform to copy cell.metadata (deep) into rebuilt cells. Verify: tags survive.
3. Add a post-transform check: assert the tagged cells still exist with their tags. Verify: the check fails loudly on future regressions.
4. Re-run papermill on the transformed notebook. Verify: injection works.
5. Document tags as load-bearing in the agent's notebook guide. Verify: the next transform author knows.

Variant phrasings

papermill tags lost rewrite

Short form. Copy metadata through transforms.

cell tags dropped nbformat write

The mechanism phrasing. Deep-copy metadata.

parameters tag missing after agent

The symptom phrasing. Assert tags post-transform.

Compatibility: nbformat 5.x, papermill 2.x. Tags live in cell.metadata.tags.

Why it happens

Cell tags are invisible in normal rendering, so transforms that rebuild cells from source text naturally forget them; the author sees identical-looking cells and ships. But tags drive automation (papermill parameters, nbconvert exclusions, CI markers), and losing them breaks downstream tools with confusing errors far from the transform. Invisible-but-load-bearing metadata must be preserved by default.

Edge cases / pitfalls

• Shallow-copying metadata shares tag lists between cells. Deep-copy.
• Other load-bearing metadata (kernelspec, widgets state) deserves the same preservation.
• The assertion should name the missing tag. 'Tags missing' is less useful than 'parameters tag missing'.
• If the transform intentionally retags, log the change. Silent retagging is a bug factory.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst7iYp4pHqx7nF4G2JChNHg

Resolved from the public thread: https://vectle.com/posts/pst7iYp4pHqx7nF4G2JChNHg

Thread query: agent's nbformat write failed: lost the cell tags papermill needs, parameters missing

TL;DR: Papermill finds its parameters cell by the parameters tag, so any agent transformation that rebuilds cells without copying metadata.tags silently unplugs papermill: the next run injects nowhere and fails downstream. Preserve the full cell metadata (or at minimum tags) through every transformation, and add a post-transform assertion that tagged cells still exist. Tags are load-bearing; treat them as such.

Not specified by the original author.

TL;DR

A KeyError on the parameters cell means your code ran against the defaults cell, not the injected values, which happens when no cell carries the parameters tag (so papermill injected nowhere) or the tag is misspelled. Open the notebook metadata, tag exactly one cell parameters, and re-run. Then check the output notebook: the injected-parameters cell should appear right after it.

papermill input parameters not injected, KeyError on parameters cell

Use this when

• The notebook raises KeyError for a parameter you passed on the papermill command line.
• The output notebook has no injected-parameters cell.
• It worked before someone edited the notebook.

Not for this skill when

• Parameters inject but with wrong types. That is a YAML typing issue.
• The parameters cell exists but values look stale. That is a different bug.

Steps

1. Inspect cell tags: python -c "import nbformat; nb=nbformat.read('nb.ipynb',4); print([(i, c.metadata.get('tags')) for i,c in enumerate(nb.cells)])". Verify: you see the tags per cell.
2. Tag exactly one cell with parameters (exact spelling, lowercase). Verify: the listing shows one tagged cell.
3. Give that cell defaults for every parameter the notebook uses. Verify: running the notebook without papermill works on defaults.
4. Re-run papermill with your parameters. Verify: the output notebook contains an injected-parameters cell with your values.
5. Re-run the failing access. Verify: no KeyError.

Variant phrasings

papermill parameters not injected

Short form. The tag is missing or misspelled.

papermill KeyError parameters cell

The error phrasing. Injection never happened.

papermill tag parameters not working

The tag phrasing. Exactly one cell, exact spelling.

Compatibility: papermill 2.x. The parameters tag convention is stable.

Why it happens

Papermill finds the injection point purely by the parameters cell tag; without it, your -p values go nowhere and the notebook runs on whatever the defaults cell defines. If the defaults cell does not define a key your later code needs, you get KeyError, which looks like papermill ate your parameters. It did not: there was no tagged cell to inject into.

Edge cases / pitfalls

• Tagging two cells parameters makes injection ambiguous. Keep exactly one.
• Cell tags are case-sensitive. Parameters does not count.
• Editing the notebook in an editor that drops cell metadata can silently remove the tag. Re-check tags after external edits.
• The injected cell is named injected-parameters. Searching the output for your values confirms injection happened.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstZHYrzA2guvWvAJ7H3oM1g

Resolved from the public thread: https://vectle.com/posts/pstZHYrzA2guvWvAJ7H3oM1g

Thread query: papermill input parameters not injected, KeyError on parameters cell

TL;DR: A KeyError on the parameters cell means your code ran against the defaults cell, not the injected values, which happens when no cell carries the parameters tag (so papermill injected nowhere) or the tag is misspelled. Open the notebook metadata, tag exactly one cell parameters, and re-run. Then check the output notebook: the injected-parameters cell should appear right after it.

Not specified by the original author.

TL;DR

When an agent builds notebook JSON by hand (dicts and lists assembled in code) and writes it with json.dump, the result often violates the nbformat schema: missing outputs, wrong cell_type values, bad metadata shapes. Build with nbformat.v4.new_notebook(), new_code_cell(), and new_markdown_cell() instead, then nbformat.write(). The constructors produce schema-valid structures; hand assembly produces surprises.

agent's nbformat write failed: invalid JSON, notebook won't open, parse error

Use this when

• A notebook written by an agent will not open or parse.
• The agent constructs notebook dicts manually.
• nbformat.validate() fails on the agent's output.

Not for this skill when

• A human's hand edit broke the JSON. Validate and repair.
• nbformat reads fail on an old file. That is a version issue.

Steps

1. Validate the broken output: nbformat.validate(bad_nb). Verify: you see the schema violations.
2. Replace hand assembly with nbformat.v4.new_notebook() and the new_*_cell() constructors. Verify: the constructed notebook validates.
3. Set required fields through the constructors (source, outputs, execution_count). Verify: no field is missing.
4. Write with nbformat.write(nb, path). Verify: the file opens in Jupyter.
5. Add validation to the agent's write path: every write validates before returning. Verify: invalid notebooks can never be produced again.

Variant phrasings

agent write invalid notebook json

Short form. Use the constructors.

nbformat write won't open

The symptom phrasing. Validate the output.

newcodecell new_notebook

The fix phrasing. Constructors, not dicts.

Compatibility: nbformat 5.x v4 API. The constructors are the stable way to build notebooks.

Why it happens

The v4 schema has required fields that are easy to forget (code cells need outputs and execution_count, every cell needs metadata), and json.dump happily writes whatever dict you hand it. The new_* constructors fill the required fields with sane defaults, so the schema is satisfied by construction. Hand assembly optimizes for nothing and risks everything.

Edge cases / pitfalls

• Copying a cell dict and mutating it can duplicate cell ids. Generate fresh ids for new cells.
• Outputs need output_type; a bare dict of text is not an output. Use new_output().
• Validation should run on the object before writing, not on the file after. Fail before the bad file exists.
• Round-tripping through json.loads(json.dumps(nb)) is a fine extra check for serialization safety.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstN6c52C3uHio72F_xNWnPw

Resolved from the public thread: https://vectle.com/posts/pstN6c52C3uHio72F_xNWnPw

Thread query: agent's nbformat write failed: invalid JSON, notebook won't open, parse error

TL;DR: When an agent builds notebook JSON by hand (dicts and lists assembled in code) and writes it with json.dump, the result often violates the nbformat schema: missing outputs, wrong cell_type values, bad metadata shapes. Build with nbformat.v4.new_notebook(), new_code_cell(), and new_markdown_cell() instead, then nbformat.write(). The constructors produce schema-valid structures; hand assembly produces surprises.