JSONPad

Update an item

update_item

DestructiveIdempotent

Change an item's metadata (description, tags, version, readonly, activated) and, with data, replace all of its data. To change only some of the data, use merge_item_data or patch_item_data. On a list with guard indexes, replacing the whole data would delete the values this token can't see, so it's refused unless overwriteGuarded is set. Pass the etag you read as ifMatch. 1 request (plus 1 to find the list's guard indexes, the first time).

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "list": "<list>",
      "item": "<item>"
    },
    "name": "update_item"
  }
}

Input Schema

Name	Required	Description
`data`	No	Replaces all of the item's data
`item`	Yes	The item: its id or alias value (a deleted item only by id)
`list`	Yes	The list: its id or pathName
`tags`	No	Tags (at most 20). Replaces the existing tags
`ifMatch`	No	The etag you read the item with. The write only happens if nobody has changed the item since; otherwise it fails with ITEM_PRECONDITION_FAILED and nothing is written. Pass it whenever the write is based on something you read
`version`	No
`readonly`	No
`activated`	No
`returnData`	No	Return the item's data after the write (default: metadata only)
`description`	No
`overwriteGuarded`	No	Write even though it replaces values hidden by guard indexes, deleting them. Only if the user means to

Output Schema

Name	Required	Description	Default
`etag`	Yes
`item`	Yes

Schema Changelog

Changes observed during successful MCP inspections.

First observedOct 2, 2026

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations (destructiveHint=true, idempotentHint=true), the description discloses concrete behavioral traits: guard-index lists refuse a full data replace unless overwriteGuarded is set, the write fails with ITEM_PRECONDITION_FAILED and nothing is written on etag mismatch, and it notes the request cost (1 request, plus 1 the first time to find guard indexes). That is meaningful context the annotations alone don't convey; it stops short only of describing the returned metadata shape, which the output schema covers.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the core action, then layers the alternative tools, the guard-index refusal, the etag precondition and the request cost in a tight block. Every sentence carries operational information and none is redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an 11-parameter destructive mutation with annotations and an output schema, the description supplies the missing decision-critical pieces: alternatives, guard-index behavior, etag precondition semantics and cost. Return values are covered by the output schema, so nothing an agent needs to call this correctly is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 64%, so the schema already documents data, item, list, tags, ifMatch, returnData and overwriteGuarded. The description adds real meaning on top: it clarifies that data replaces all data, that ifMatch is the read etag gating the write, and that overwriteGuarded overrides guard-index protection. The four bare parameters (version, readonly, activated, description) are only named as metadata fields, so it doesn't fully close the gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Change an item's metadata... and, with data, replace all of its data') and enumerates the affected fields. It explicitly names the sibling tools merge_item_data and patch_item_data, so an agent can distinguish this replace-oriented update from partial-data updates without opening any schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Gives explicit routing rules: use merge_item_data or patch_item_data to change only some data, and set overwriteGuarded only when the user means to delete guarded values. It also tells the caller to pass the etag as ifMatch whenever the write is based on a read, covering the when-to-use and when-not conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All JSONPad tools Inspect

Try in Browser

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources

Need Help?