A
licenseNot graded
qualityF
maintenanceA comprehensive MCP server for Google Sheets integration with Claude, enabling spreadsheet discovery, data manipulation, and formatting through natural language commands and slash commands.
19
MIT
mcp-gsheets
by freema
The mcp-gsheets server enables comprehensive integration with Google Sheets API, allowing you to:
Spreadsheet Management: Create new spreadsheets, check access permissions, and retrieve metadata
Sheet Operations: Add, delete, duplicate, and copy sheets; update properties like title, tab color, and frozen panes
Data Handling: Read values from ranges, update existing data, append new rows, and clear cell contents
Formatting: Apply cell formatting (colors, fonts, alignment), manage borders, merge/unmerge cells, and add conditional formatting
Advanced Features: Create and manage charts, perform batch operations for better efficiency
Integrates with Google Cloud for authentication and project configuration, allowing access to Google Cloud resources using service account credentials.
Enables reading, writing, and managing Google Sheets documents through a comprehensive set of tools including reading cell values, batch operations, appending rows, clearing cells, sheet management, and cell formatting capabilities.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-gsheetsget the sales data from sheet Q1-2024"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP Google Sheets Server
A Model Context Protocol (MCP) server for Google Sheets API integration. Enables reading, writing, and managing Google Sheets documents directly from your MCP client (e.g., Claude Code, Claude Desktop, Cursor, etc.).
Key Features
Complete Google Sheets Integration: Read, write, and manage spreadsheets
Advanced Operations: Batch operations, formatting, charts, and conditional formatting
Flexible Authentication: Support for both file-based and JSON string credentials
Production Ready: Built with TypeScript, comprehensive error handling, and full test coverage
Related MCP server: sheetsdb-mcp-server
Requirements
Node.js v20 or higher
Google Cloud Project with Sheets API enabled
Service Account with JSON key file
Getting Started
Quick Install (Recommended)
Add the following config to your MCP client:
{
"mcpServers": {
"mcp-gsheets": {
"command": "npx",
"args": ["-y", "mcp-gsheets@latest"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_APPLICATION_CREDENTIALS": "/absolute/path/to/service-account-key.json"
}
}
}
}NOTE
Usingmcp-gsheets@latest ensures that your MCP client will always use the latest version of the MCP Google Sheets server.
MCP Client Configuration
claude mcp add mcp-gsheets npx mcp-gsheets@latestAfter adding, edit your Claude Code config to add the required environment variables:
{
"mcpServers": {
"mcp-gsheets": {
"command": "npx",
"args": ["mcp-gsheets@latest"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_APPLICATION_CREDENTIALS": "/absolute/path/to/service-account-key.json"
}
}
}
}Add to your Claude Desktop config:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/claude/claude_desktop_config.json
{
"mcpServers": {
"mcp-gsheets": {
"command": "npx",
"args": ["-y", "mcp-gsheets@latest"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_APPLICATION_CREDENTIALS": "/absolute/path/to/service-account-key.json"
}
}
}
}Go to Cursor Settings → MCP → New MCP Server. Use the config provided above.
Follow https://docs.cline.bot/mcp/configuring-mcp-servers and use the config provided above.
For other MCP clients, use the standard configuration format shown above. Ensure the command is set to npx and include the environment variables for Google Cloud authentication.
Google Cloud Setup
Go to Google Cloud Console
Create a new project or select existing
Enable Google Sheets API:
Navigate to "APIs & Services" → "Library"
Search for "Google Sheets API" and click "Enable"
Create Service Account:
Go to "APIs & Services" → "Credentials"
Click "Create Credentials" → "Service Account"
In the service accounts list, click the three dots in the
Actionscolumn →Manage keys→Add key→Create new key→ select JSON formatDownload the JSON key file
Share your spreadsheets:
Open your Google Sheet
Click Share and add the service account email (from JSON file)
Grant "Editor" permissions
Alternative Authentication Methods
Option 1: JSON String Authentication
Instead of using a file path for credentials, you can provide the service account credentials directly as a JSON string. This is useful for containerized environments, CI/CD pipelines, or when you want to avoid managing credential files.
{
"mcpServers": {
"mcp-gsheets": {
"command": "npx",
"args": ["-y", "mcp-gsheets@latest"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_SERVICE_ACCOUNT_KEY": "{\"type\":\"service_account\",\"project_id\":\"your-project\",\"private_key_id\":\"...\",\"private_key\":\"-----BEGIN PRIVATE KEY-----\\n...\\n-----END PRIVATE KEY-----\\n\",\"client_email\":\"...@....iam.gserviceaccount.com\",\"client_id\":\"...\",\"auth_uri\":\"https://accounts.google.com/o/oauth2/auth\",\"token_uri\":\"https://oauth2.googleapis.com/token\",\"auth_provider_x509_cert_url\":\"https://www.googleapis.com/oauth2/v1/certs\",\"client_x509_cert_url\":\"...\"}"
}
}
}
}Note: When using GOOGLE_SERVICE_ACCOUNT_KEY:
The entire JSON must be on a single line
All quotes must be escaped with backslashes
Newlines in the private key must be represented as
\\nIf the JSON includes a
project_id, you can omitGOOGLE_PROJECT_ID
Option 2: Private Key Authentication (Simplified)
For the most user-friendly approach, you can provide just the private key and email directly. This is the simplest method and requires only two fields from your service account JSON:
{
"mcpServers": {
"mcp-gsheets": {
"command": "npx",
"args": ["-y", "mcp-gsheets@latest"],
"env": {
"GOOGLE_PRIVATE_KEY": "-----BEGIN PRIVATE KEY-----\\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCgR6bvMNOUHZ29\\n+YgbVHAXsT/s+L/jnXTCB193zikCzspSBSfxLu8VRDjkNq9WUoDxizTATzMFNvNf\\n...\\n-----END PRIVATE KEY-----\\n",
"GOOGLE_CLIENT_EMAIL": "spreadsheet@your-project.iam.gserviceaccount.com"
}
}
}
}Note: When using GOOGLE_PRIVATE_KEY:
Newlines in the private key should be represented as
\\nThe private key must include the
-----BEGIN PRIVATE KEY-----and-----END PRIVATE KEY-----markersThe client email should be the service account email from your JSON file
GOOGLE_PROJECT_IDis optional when using this method
Local Development Setup
If you want to develop or contribute to this project, you can clone and build it locally:
# Clone the repository
git clone https://github.com/freema/mcp-gsheets.git
cd mcp-gsheets
# Install dependencies
npm install
# Build the project
npm run buildInteractive Setup Script
Run the interactive setup script to configure your local MCP client:
npm run setupThis will:
Guide you through the configuration
Automatically detect your Node.js installation (including nvm)
Find your Claude Desktop config
Create the proper JSON configuration
Optionally create a .env file for development
Manual Local Configuration
If you prefer manual configuration with a local build, add to your MCP client config:
{
"mcpServers": {
"mcp-gsheets": {
"command": "node",
"args": ["/absolute/path/to/mcp-gsheets/dist/index.js"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_APPLICATION_CREDENTIALS": "/absolute/path/to/service-account-key.json"
}
}
}
}📦 Build & Development
Development Commands
# Development mode with hot reload
npm run dev
# Build for production
npm run build
# Type checking
npm run typecheck
# Clean build artifacts
npm run clean
# Run MCP inspector for debugging
npm run inspector
# Run MCP inspector in development mode
npm run inspector:devTask Runner (Alternative)
If you have Task installed:
# Install dependencies
task install
# Build the project
task build
# Run in development mode
task dev
# Run linter
task lint
# Format code
task fmt
# Run all checks
task checkDevelopment Setup
Create
.envfile for testing:
cp .env.example .env
# Edit .env with your credentials:
# GOOGLE_PROJECT_ID=your-project-id
# GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
# TEST_SPREADSHEET_ID=your-test-spreadsheet-idRun in development mode:
npm run dev # Watch mode with auto-reload🎚️ Reducing context cost with toolsets
All 44 tools together cost about 9,900 tokens of context in every session,
before the model does anything. Most workflows need a fraction of that.
GSHEETS_TOOLSETS limits which tools the server exposes:
{
"mcpServers": {
"gsheets": {
"command": "npx",
"args": ["mcp-gsheets"],
"env": {
"GOOGLE_PROJECT_ID": "your-project-id",
"GOOGLE_APPLICATION_CREDENTIALS": "/path/to/key.json",
"GSHEETS_TOOLSETS": "core,charts"
}
}
}
}Toolset | Tools | What it covers |
| 11 | Read/write values, metadata, sheet structure, create spreadsheet |
| 9 | Sheet lifecycle, rows and columns |
| 15 | Colours, borders, merges, conditional rules, links, dates |
| 3 | Create, update, delete charts |
| 4 | Native tables |
| 2 | Full-sheet snapshot, range comparison |
Measured tools/list cost:
Configuration | Tools | ≈ Tokens |
unset (default, all toolsets) | 44 | 9,875 |
| 11 | 1,986 |
| 20 | 3,548 |
| 16 | 3,599 |
| 6 | 912 |
Notes:
The default is unchanged — leave
GSHEETS_TOOLSETSunset and you get every tool, exactly as before.coreis always included.GSHEETS_TOOLSETS=chartsmeans "charts as well as core", not "charts only" — without core the server cannot read a cell.A typo is a startup error, not a silently smaller tool list.
GSHEETS_READ_ONLY=truedrops every writing tool and can be combined withGSHEETS_TOOLSETS. It is enforced when a tool is called, not just when the list is built, so a client cannot write by naming a hidden tool.
All tools also carry MCP annotations (readOnlyHint, destructiveHint,
idempotentHint), so clients can skip confirmation prompts on reads and warn
before destructive operations.
📋 Available Tools
Reading Data
Tool | Description | Key Parameters |
| Read cell values from a single range |
|
| Read cell values from multiple ranges in one request |
|
| Get spreadsheet metadata: title, locale, sheets list with IDs, row/column counts |
|
| Verify that the service account can access a spreadsheet |
|
Writing Data
Tool | Description | Key Parameters |
| Write values to a single range (overwrites existing content) |
|
| Write values to multiple ranges in one request |
|
| Append rows after the last row of an existing table. Default |
|
| Clear all values in a range (preserves formatting) |
|
| Insert blank or pre-filled rows at a specific position |
|
| Delete one or more columns using a full-column A1 range |
|
| Delete one or more rows using a full-row A1 range |
|
| Insert a hyperlink formula into a cell |
|
| Insert a date/datetime value formatted correctly into a cell |
|
Sheet Management
Tool | Description | Key Parameters |
| Create a new Google Sheets file |
|
| Add a new sheet tab to an existing spreadsheet |
|
| Remove a sheet tab by its numeric sheet ID |
|
| Copy a sheet within the same spreadsheet |
|
| Copy a sheet to a different spreadsheet |
|
| Rename a sheet, change tab colour, toggle grid lines, etc. |
|
| Delete multiple sheet tabs in one request |
|
Cell Formatting
Tool | Description | Key Parameters |
| Apply background colour, font style, alignment and number format to a range |
|
| Apply different formats to multiple ranges in one request |
|
| Set or remove borders on a range (style, width, colour per side) |
|
| Merge a range of cells |
|
| Unmerge previously merged cells in a range |
|
| Add a conditional formatting rule (gradient or boolean) to a range |
|
Native Tables
Tool | Description | Key Parameters |
| Create a native Google Sheets table with typed columns and optional dropdown values |
|
| Update an existing native Google Sheets table by table ID using an explicit field mask |
|
| Delete a native Google Sheets table by table ID |
|
| Read native tables for a spreadsheet or a specific sheet |
|
Charts
Tool | Description | Key Parameters |
| Create a bar, line, pie, column or other chart on a sheet |
|
| Modify an existing chart's spec or position |
|
| Remove a chart from a spreadsheet |
|
Read / Snapshot Tools
Tool | Description | Key Parameters |
| Return all merged cell ranges for a sheet, with A1 notation and raw GridRange coordinates |
|
| Return column widths, row heights, frozen column/row counts, and hidden flags for every column and row |
|
| Read raw cell formatting (background colour, font, borders, alignment, number format) for a range without returning cell values |
|
| Read all conditional formatting rules and banded (alternating-colour) ranges defined on a sheet |
|
| Lightweight structural metadata only — no per-cell data. Returns dimensions, frozen rows/cols, tab colour, column widths, row heights, hidden columns/rows, and all merges in A1 notation. Single fast API call |
|
| Read cell formatting for a range and return it as compact A1Range→format pairs (run-length encoded). Identical adjacent cells are collapsed into rectangular ranges — reduces output by 90 %+ compared to per-cell data |
|
| Master one-shot tool — returns all structural and formatting metadata (merges, dimensions, conditional formatting, and optionally cell formatting) in a single API call. Supports |
|
| Read the Basic Filter (AutoFilter) configuration for a sheet, including filtered range, sort specs, and per-column filter criteria (hidden values, conditions, colour filters) |
|
| Read data validation rules (checkboxes, dropdowns, custom formulas) from a sheet or range. Returns compact run-length-encoded list of unique rules grouped by cell ranges |
|
🔧 Code Quality
Linting
# Run ESLint
npm run lint
# Fix auto-fixable issues
npm run lint:fixFormatting
# Check formatting with Prettier
npm run format:check
# Format code
npm run formatType Checking
# Run TypeScript type checking
npm run typecheck❗ Troubleshooting
Common Issues
"Authentication failed"
If using file-based auth: Verify JSON key path is absolute and correct
If using JSON string auth: Ensure JSON is properly escaped and valid
If using private key auth: Check that the private key includes BEGIN/END markers and newlines are escaped as
\\nVerify GOOGLE_CLIENT_EMAIL is a valid service account email
Check GOOGLE_PROJECT_ID matches your project (or is included in JSON for full JSON auth)
Ensure Sheets API is enabled
"Permission denied"
Share spreadsheet with service account email
Service account needs "Editor" role
Check email in JSON file (client_email field)
"Spreadsheet not found"
Verify spreadsheet ID from URL
Format:
https://docs.google.com/spreadsheets/d/[SPREADSHEET_ID]/edit
MCP Connection Issues
Ensure you're using the built version (
dist/index.js)Check that Node.js path is correct in Claude Desktop config
Look for errors in Claude Desktop logs
Use
npm run inspectorto debug
🔍 Finding IDs
Spreadsheet ID
From the URL:
https://docs.google.com/spreadsheets/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OgvE2upms/edit
↑ This is the spreadsheet IDSheet ID
Use sheets_get_metadata to list all sheets with their IDs.
📝 Tips
Always test with a copy of your data
Use batch operations for better performance
Set appropriate permissions (read-only vs edit)
Check rate limits for large operations
Use
sheets_check_accessto verify permissions before operations
📘 Tool Details
sheets_get_sheet_structure
Returns lightweight structural/dimensional metadata for a sheet without any per-cell data. Much faster and cheaper than sheets_get_full_sheet_snapshot when you only need layout information.
Parameters:
spreadsheetId(required): The ID of the spreadsheetsheetName(required): Name of the sheet (tab)
Returns: sheetName, sheetId, sheetIndex, tabColor, tabColorStyle, dimensions (rowCount, columnCount), frozen (rowCount, columnCount), columnWidths (array of pixel sizes), rowHeights (array of pixel sizes), hiddenColumns (0-based indices), hiddenRows (0-based indices), mergeCount, merges (A1 notation array)
sheets_get_formatting_compact
Read cell formatting for a range and return it as compact A1Range → format pairs. Adjacent cells with identical formatting are collapsed into rectangular ranges (run-length encoded), reducing output by 90 %+ compared to per-cell data.
Parameters:
spreadsheetId(required): The ID of the spreadsheetsheetName(required): Name of the sheet (tab)range(required): Range without sheet prefix, e.g."A1:Z85"useEffectiveFormat(optional):false(default) = userEnteredFormat (only explicit overrides, smaller output);true= effectiveFormat (all inherited defaults)fields(optional): Array of format field names to include, e.g.["backgroundColor", "textFormat", "borders"]
Returns: { range, formatType, rangeCount, data: { "A1:C3": { backgroundColor: {...} }, ... } }
Supported fields: backgroundColor, backgroundColorStyle, textFormat, horizontalAlignment, verticalAlignment, wrapStrategy, textRotation, numberFormat, padding, borders
sheets_get_full_sheet_snapshot
Master one-shot tool that returns all structural and formatting metadata in a single API call.
Parameters:
spreadsheetId(required): The ID of the spreadsheetsheetName(required): Name of the sheet (tab)includeFormattingRange(optional): If provided (e.g."A1:Z100"), per-cell formatting is included in the responseuseEffectiveFormat(optional): Use effectiveFormat instead of userEnteredFormat when including cell formatting (default:false)fields(optional): Array of format field names to return, e.g.["backgroundColor", "textFormat"]— reduces API transfer size and response sizecompactMode(optional): Whentrue, identical adjacent cells are collapsed into rectangular ranges (RLE). Reduces a typical 85×28 sheet from ~60 000 lines to ~500 lines (default:false)
sheets_insert_rows
Insert new rows at a specific position in a spreadsheet with optional data.
Parameters:
spreadsheetId(required): The ID of the spreadsheetrange(required): A1 notation anchor point where rows will be inserted (e.g., "Sheet1!A5")rows(optional): Number of rows to insert (default: 1)position(optional): 'BEFORE' or 'AFTER' the anchor row (default: 'BEFORE')inheritFromBefore(optional): Whether to inherit formatting from the row before (default: false)values(optional): 2D array of values to fill the newly inserted rowsvalueInputOption(optional): 'RAW' or 'USER_ENTERED' (default: 'USER_ENTERED')
Examples:
// Insert 1 empty row before row 5
{
"spreadsheetId": "your-spreadsheet-id",
"range": "Sheet1!A5"
}
// Insert 3 rows after row 10 with data
{
"spreadsheetId": "your-spreadsheet-id",
"range": "Sheet1!A10",
"rows": 3,
"position": "AFTER",
"values": [
["John", "Doe", "john@example.com"],
["Jane", "Smith", "jane@example.com"],
["Bob", "Johnson", "bob@example.com"]
]
}sheets_delete_columns
Delete one or more columns from a sheet using a full-column A1 range.
Parameters:
spreadsheetId(required): The ID of the spreadsheetrange(required): Full-column A1 range to delete (e.g., "Sheet1!B:D" or "Sheet1!C:C")
Examples:
// Delete columns B through D from Sheet1
{
"spreadsheetId": "your-spreadsheet-id",
"range": "Sheet1!B:D"
}
// Delete a single column from the first sheet
{
"spreadsheetId": "your-spreadsheet-id",
"range": "C:C"
}sheets_delete_rows
Delete one or more rows from a sheet using a full-row A1 range.
Parameters:
spreadsheetId(required): The ID of the spreadsheetrange(required): Full-row A1 range to delete (e.g., "Sheet1!2:4" or "Sheet1!3:3")
Examples:
// Delete rows 2 through 4 from Sheet1
{
"spreadsheetId": "your-spreadsheet-id",
"range": "Sheet1!2:4"
}
// Delete a single row from the first sheet
{
"spreadsheetId": "your-spreadsheet-id",
"range": "3:3"
}📋 Changelog
See CHANGELOG.md for a list of changes in each version.
🤝 Contributing
Fork the repository
Create your feature branch (
git checkout -b feature/amazing-feature)Run tests and linting (
npm run check)Commit your changes (
git commit -m 'Add some amazing feature')Push to the branch (
git push origin feature/amazing-feature)Open a Pull Request
👤 Author
Tomáš Grásl - tomasgrasl.cz
📄 License
This project is licensed under the MIT License - see the LICENSE file for details.
Available Tools
44 toolssheets_add_conditional_formattingCIdempotent
Add conditional formatting rules to a Google Sheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| rules | Yes | ||
| spreadsheetId | Yes |
TDQS
C2.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, so the agent knows it's a safe, idempotent write operation. The description adds no additional behavioral context (e.g., how rules are merged, conflict behavior, or reply details), providing zero value beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no fluff, but it is drastically under-specified for the tool's complexity. While it scores well on brevity, it fails to earn its place by omitting critical usage details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a very complex nested schema (rules with conditions, formats, gradient points) and no output schema. The description provides only a high-level action, leaving out the structure of rules, condition types, and formatting options. It is severely incomplete for an agent to make correct calls.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description offers no explanation of the two required parameters (spreadsheetId, rules) or the complex nested structure. The agent must rely entirely on the raw schema, which is extensive but lacks semantic hints on how to construct rules (e.g., boolean vs. gradient, condition types).
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?
The description clearly states the tool's purpose: 'Add conditional formatting rules to a Google Sheet' with a specific verb ('Add') and resource ('conditional formatting rules'). It distinguishes from sibling sheets_get_conditional_formatting which retrieves rules.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states what it does, not when to choose it over other tools like sheets_get_conditional_formatting or sheets_format_cells.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_add_tableAIdempotent
Create a native Google Sheets table with typed columns and optional dropdown values
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Unique table name within the spreadsheet | |
| range | Yes | A1 notation range for the table, e.g. "A1:D20" or "Sheet1!A1:D20" | |
| columns | Yes | Column definitions for the table | |
| sheetName | Yes | Name of the sheet (tab) where the table will be created | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, so the description does not need to repeat those safety traits. However, it adds no additional behavioral context, such as potential side effects, permissions required, or behavior on duplicate names. It is not misleading, but it is minimal.
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?
The description is a single, front-loaded sentence that conveys the core purpose without any filler. Every word contributes to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a create operation with full schema documentation and non-destructive annotations, the description provides sufficient context. It covers the essential action and distinguishing features, and the schema handles parameter specifics. The lack of output schema or explicit return value explanation is a minor gap, but not critical for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all five parameters. The description adds no extra parameter details beyond mentioning 'typed columns and optional dropdown values,' which is already reflected in the columnType and dropdownValues fields. Baseline 3 is appropriate.
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?
The description clearly states the verb 'Create' and resource 'native Google Sheets table' with specific attributes (typed columns, optional dropdown values). It effectively distinguishes this tool from sibling tools like sheets_update_table, sheets_delete_table, and sheets_get_tables.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating a Google Sheets table, but it does not explicitly state when to use this tool over alternatives or provide exclusions. The purpose is clear, but there is no direct comparison to related operations like updating or deleting tables.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_append_valuesA
Append values to the end of a table in a Google Sheets spreadsheet. IMPORTANT: By default, this will OVERWRITE existing empty cells. To INSERT new rows instead, set insertDataOption to "INSERT_ROWS".
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | The A1 notation range of the table to append to (e.g., "Sheet1!A:B") | |
| values | Yes | A 2D array of values to append, where each inner array represents a row | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| insertDataOption | No | How the input data should be inserted (default: OVERWRITE) | |
| valueInputOption | No | How the input data should be interpreted (default: USER_ENTERED) |
TDQS
A4.4/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the critical default behavior that existing empty cells will be overwritten, which adds meaningful context beyond the destructiveHint=false annotation. It also offers a clear remediation path (INSERT_ROWS). It does not mention authentication, return values, or effects on non-empty cells, but the key risk is addressed.
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?
The description is two sentences with no wasted words. The important warning about overwriting is front-loaded and immediately actionable, and the structure makes it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's 5 parameters, nested values array, and lack of output schema, the description covers the most consequential behavioral nuance (insert vs overwrite) while the schema handles parameter details. It could mention return values or explicitly compare with sheets_update_values, but it is largely sufficient for the task.
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?
The input schema already documents all 5 parameters with 100% coverage, so the baseline is 3. The description adds value by explaining the practical implication of the insertDataOption enum (OVERWRITE vs INSERT_ROWS) and its default, which the schema alone does not convey. It does not add detail for values or range, but those are already well-described in the schema.
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?
The description clearly identifies the specific action ('Append values to the end of a table') and the resource ('Google Sheets spreadsheet'), which distinguishes it from update, clear, and insert-related sibling tools. The mention of 'end of a table' makes the scope precise and differentiates it from other write operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context that this tool is for appending to a table and explicitly tells the user how to choose between overwriting empty cells and inserting new rows via insertDataOption. However, it does not explicitly name alternative sibling tools or give a when-not-to-use statement, so it falls short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_batch_delete_sheetsAIdempotent
Delete multiple sheets from a Google Sheets spreadsheet in a single operation
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetIds | Yes | Array of sheet IDs to delete (use sheets_get_metadata to find sheet IDs) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the destructive action (deleting sheets) but adds no further context about irreversibility, error handling, or partial failures. The idempotentHint annotation provides some behavioral cue, but the description itself does not go beyond stating the obvious resource affected.
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?
The description is a single, well-structured sentence that front-loads the verb and resource. Every word earns its place, and there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple batch-delete operation with only two parameters and no output schema, the description is sufficiently complete. It tells the agent what the tool does, and the schema fills in parameter details. The lack of a return-value explanation is not a concern given there is no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with descriptions, so the tool description does not need to add much. It adds no additional meaning beyond what the schema already provides, hence the baseline score of 3.
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?
The description clearly states the action (delete), the resource (multiple sheets in a spreadsheet), and the batch nature ('in a single operation'). This distinguishes it from the sibling tool sheets_delete_sheet, which handles single-sheet deletion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'in a single operation' provides clear context for when to use this tool (when deleting multiple sheets at once). However, it does not explicitly mention the alternative for single-sheet deletion or any exclusions, stopping short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_batch_format_cellsAIdempotent
Format multiple cell ranges in a Google Sheet in a single operation
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| formatRequests | Yes | Array of format requests, each containing a range and format object |
TDQS
A3.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide idempotentHint: true and destructiveHint: false, covering the safety profile. The description adds the batching behavior but does not disclose additional traits like overwriting existing formatting or performance implications.
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?
The description is a single 12-word sentence that front-loads the purpose without any filler or redundant information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich schema and annotations, the description is adequate for a straightforward batch formatting tool. However, it lacks guidance on constructing format objects and does not mention potential side effects like replacing existing formatting, leaving some gaps for complex use cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters (spreadsheetId and formatRequests) already described. The description adds no extra meaning beyond the schema, so the baseline of 3 applies.
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?
The description clearly states the action (Format) and scope (multiple cell ranges in a Google Sheet), distinguishing it from the single-range sibling tool sheets_format_cells by emphasizing 'multiple' and 'in a single operation'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies batching ('multiple cell ranges', 'single operation') but does not explicitly state when to use this tool over alternatives like sheets_format_cells, nor does it provide any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_batch_get_valuesARead-onlyIdempotent
Get values from multiple ranges in a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| ranges | Yes | Array of A1 notation ranges to retrieve (e.g., ["Sheet1!A1:B10", "Sheet2!C1:D5"]) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| majorDimension | No | The major dimension of the values (default: ROWS) | |
| valueRenderOption | No | How values should be represented (default: FORMATTED_VALUE) |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so the safe, idempotent behavior is covered. The description adds no further behavioral context, such as return format or rate limits, but it is consistent with the annotations and does not contradict them.
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?
The description is a single, concise sentence with no redundant or filler words. It conveys the tool's core purpose immediately and saves the agent time.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a straightforward read tool, the description is mostly sufficient, especially with detailed schema and annotations. However, since there is no output schema, it would be helpful to mention that the response returns a map of ranges to values, and that it is more efficient than multiple single-range calls. This minor gap prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% description coverage for all 4 parameters, including clear definitions and examples for ranges, spreadsheetId, majorDimension, and valueRenderOption. The description itself adds no parameter-specific meaning, so the baseline of 3 applies.
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?
The description uses a specific verb 'Get' with resource 'values' and scope 'multiple ranges' in a Google Sheets spreadsheet. This clearly distinguishes it from sibling tools like sheets_get_values (single range) and write operations such as sheets_batch_update_values.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'multiple ranges' implies when to use this tool (when needing more than one range), but it does not explicitly state when not to use it or recommend alternatives such as sheets_get_values for single ranges. No exclusions or contrasting guidance are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_batch_update_valuesAIdempotent
Update values in multiple ranges of a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| data | Yes | Array of range-value pairs to update | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| valueInputOption | No | How the input data should be interpreted (default: USER_ENTERED) |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, so safety profile is known. The description adds no additional behavioral context, such as how existing values in the ranges are affected or how valueInputOption influences interpretation. It neither contradicts annotations nor enriches them.
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?
The description is a single, concise sentence that front-loads the core action and scope. Every word is purposeful, with no redundant details or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (batch operation with nested data) and the presence of a detailed schema, the description is sufficient to understand the tool's basic function. It lacks explicit mention of overwriting behavior or response format, but these are not critical given the schema and annotations. Slight improvement could clarify how values are applied to the ranges.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with descriptions for all parameters (spreadsheetId, data, valueInputOption). The description does not add extra meaning beyond what the schema already documents, maintaining the baseline for high schema coverage.
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?
The description clearly states the tool's purpose with a specific verb ('update') and resource ('values in multiple ranges of a Google Sheets spreadsheet'). It distinguishes from sibling tools like sheets_update_values by explicitly mentioning 'multiple ranges', making its scope unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys a clear context (batch update of multiple ranges) but does not explicitly state when to use this tool over alternatives, nor does it mention exclusion criteria or specific scenarios. The guidance is implied by the wording and not spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_check_accessARead-onlyIdempotent
Check access permissions for a spreadsheet. Returns information about what operations are allowed.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| spreadsheetId | Yes | The ID of the spreadsheet to check access for |
TDQS
A4.1/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and idempotentHint=true, which cover the safety profile. The description adds that it returns information about allowed operations, but does not disclose any nuances like required auth roles or edge cases. This is adequate but not rich.
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?
The description is a single, clear sentence that states both the action and the return value. It is front-loaded, concise, and contains no irrelevant information, making it easy to parse.
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 a tool with one parameter and no output schema, the description fully conveys the tool's purpose and return value. It explains what the tool does and what information it returns, which is sufficient for an agent to select and invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameter is already well-documented. The tool description does not add extra meaning beyond the schema, but with full coverage, the baseline of 3 is appropriate.
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?
The description clearly states the tool's purpose: checking access permissions for a spreadsheet. It uses a specific verb ('check') and resource ('access permissions'), and this distinguishes it from all sibling tools, none of which are about access control.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when you need to verify access permissions for a spreadsheet. It does not explicitly name alternatives or exclusions, but given no other sibling tool provides this functionality, the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_clear_valuesAIdempotent
Clear values in a specified range of a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | The A1 notation range to clear (e.g., "Sheet1!A1:B10") | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.6/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description states that the tool clears values, which implies a destructive write operation. The idempotentHint annotation already indicates repeatability, but the description adds no further behavioral context, such as whether formatting or notes are preserved.
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?
The description is a single sentence that immediately states the action and target. It contains no redundant words, making it maximally concise while preserving clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter operation with a complete schema and idempotency annotation, the description is sufficient. It could slightly improve by noting that only values are cleared and not formatting, but the core behavior is clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully documents both parameters (spreadsheetId and range) with clear descriptions, achieving 100% coverage. The description does not add any additional parameter-specific meaning or examples beyond the schema.
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?
The description uses the specific verb 'clear' and identifies the resource as 'values in a specified range of a Google Sheets spreadsheet,' which clearly distinguishes it from sibling read, update, and append operations. It is direct and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like sheets_update_values or sheets_append_values. It also does not mention any prerequisites or exclusions, such as the fact that it only affects values and not formatting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_compare_rangesARead-onlyIdempotent
Compare cell formatting between two ranges of identical dimensions. Useful for verifying repeated patterns, e.g. "do all data rows 6–85 have identical formatting?" or "is row 10 formatted identically to the template row 5?". Returns a diff listing only the cells and properties that differ between the two ranges. Cells are compared position-by-position; rangeA and rangeB must have the same number of rows and columns. Use fields to restrict comparison to specific format properties.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Optional list of format property names to compare, e.g. ["backgroundColor", "textFormat"]. All format properties compared if omitted. | |
| rangeA | Yes | First range with sheet prefix, e.g. "Sheet1!A6:Z6" | |
| rangeB | Yes | Second range with sheet prefix, e.g. "Sheet1!A7:Z7" | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| useEffectiveFormat | No | Default: false. Compare effectiveFormat (true) or userEnteredFormat (false). effectiveFormat includes conditional formatting overlays. |
TDQS
A4.7/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint, idempotentHint), the description discloses the diff output format, positional comparison semantics, the equal-dimension requirement, and the default behavior when 'fields' is omitted. This provides a clear model of tool behavior.
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?
The description is five sentences, each adding substantive information: purpose, examples, output, dimension constraint, and fields guidance. It is front-loaded and contains no fluff or redundant details.
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?
Given the complete schema and readOnly/idempotent annotations, the description fills remaining gaps: it explains the return format (diff), comparison semantics, and the dimension constraint. The tool's behavior is fully covered for an agent.
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?
The input schema already has 100% description coverage, so the baseline is 3. The description adds value with a concrete example for 'fields' and clarifies that rangeA/rangeB must have matching dimensions, supplementing the schema's field descriptions.
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?
The description opens with a specific verb+resource+scope ('Compare cell formatting between two ranges of identical dimensions') and provides concrete example use cases. It clearly distinguishes this tool from sibling sheet tools by focusing solely on formatting comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context with examples ('do all data rows 6–85 have identical formatting?') and mentions the 'fields' parameter to restrict comparison. However, it does not explicitly state when not to use the tool or name alternatives, though no sibling tool performs the same function.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_copy_toAIdempotent
Copy a sheet to another Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetId | Yes | The ID of the sheet to copy (use sheets_get_metadata to find sheet IDs) | |
| spreadsheetId | Yes | The ID of the source spreadsheet (found in the URL after /d/) | |
| destinationSpreadsheetId | Yes | The ID of the destination spreadsheet |
TDQS
A4/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description 'Copy a sheet' adds minimal behavioral context beyond the tool name; it does not explain side effects like whether a new sheet is created in the destination or whether formatting/formulas carry over. However, given the annotation coverage, a score of 3 is appropriate.
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?
The description is a single concise sentence that front-loads the action and resource. It contains no filler, repetition, or unnecessary details, making it highly efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter tool with full schema descriptions and safety annotations, the description is nearly complete. It clearly communicates the cross-spreadsheet nature of the operation. It lacks explicit return-value info, but the absence of an output schema makes that less critical. The main gap is not mentioning prerequisites like access permissions to both spreadsheets, but that is not essential for invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema documentation covers all three parameters with descriptions of sheetId, spreadsheetId, and destinationSpreadsheetId (100% coverage). The tool description adds no additional parameter semantics beyond what the schema already provides, so the baseline of 3 applies.
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?
The description clearly states the action ('Copy') and the resource ('a sheet') with a specific destination ('another Google Sheets spreadsheet'). This distinguishes it from siblings like sheets_duplicate_sheet, which likely copies within the same spreadsheet, and sheets_insert_sheet, which creates a blank sheet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the appropriate use case: copying a sheet across spreadsheets. While it does not explicitly exclude alternatives or name a sibling tool, the phrase 'another Google Sheets spreadsheet' provides clear context for when this tool is the right choice over in-spreadsheet duplication tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_create_chartAIdempotent
Create a chart in a Google Sheets spreadsheet. Sheet names with spaces should be quoted in ranges (e.g., "My Sheet"!A1:B5). Position uses overlayPosition with anchorCell containing sheetId, rowIndex, and columnIndex.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | Chart title (optional) | |
| legend | No | Legend configuration | |
| series | Yes | Array of data series for the chart | |
| altText | No | Alternative text for accessibility | |
| leftAxis | No | Left (Y) axis configuration | |
| position | Yes | Chart position settings with overlay position. Use overlayPosition.anchorCell.sheetId to specify the sheet. | |
| subtitle | No | Chart subtitle (optional) | |
| chartType | Yes | Type of chart to create | |
| rightAxis | No | Right (Y) axis configuration | |
| domainAxis | No | Domain (X) axis configuration | |
| domainRange | No | Optional domain range in A1 notation (e.g., "A2:A5" or "My Sheet"!A2:A5). If not provided, column A will be used | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| backgroundColor | No | Chart background color |
TDQS
A3.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare idempotentHint=true and destructiveHint=false, and the description does not contradict these. The description adds context about range quoting and overlayPosition structure, but does not disclose side effects, permissions, or return value behavior, which with annotations present leaves the safety profile adequately covered.
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?
The description is only three sentences, front-loaded with the core purpose, and every sentence adds meaningful guidance. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (13 parameters, nested objects), the description focuses on the most error-prone aspects. While it does not explain all options like axes or legends, the schema descriptions cover those. The absence of an output schema is mitigated by the clear annotation hints.
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 description coverage is 100%, so the baseline is 3. The description adds value beyond the schema by centralizing the quoting rule for sheet names with spaces and clarifying the nested overlayPosition structure with anchorCell fields, which helps avoid common mistakes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Create a chart in a Google Sheets spreadsheet' with a specific verb and resource. It does not explicitly distinguish from sibling tools like sheets_update_chart or sheets_delete_chart, but the verb 'create' makes the primary purpose clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating charts but does not provide explicit when-to-use versus alternatives such as updating or deleting charts. It includes useful tips about quoting sheet names and using overlayPosition, but these are more parameter handling than usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_create_spreadsheetBIdempotent
Create a new Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| title | Yes | The title of the new spreadsheet | |
| sheets | No | Array of sheets to create in the spreadsheet |
TDQS
B3.1/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description provides no behavioral context beyond what annotations already declare. Annotations indicate idempotentHint=true and destructiveHint=false, and the description merely restates the core action without adding details like return value, permissions, or side effects. Since it adds no additional disclosure, it earns a below-baseline score despite having annotations.
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?
The description is a single, lean sentence that directly conveys the tool's purpose without wasted words. It is appropriately sized for the tool's low complexity, front-loading the action and resource clearly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with only two parameters and a complete schema, the description is nearly sufficient, but it lacks any mention of return values (e.g., spreadsheet ID or URL), which is critical for a create operation. With no output schema, the description should have specified what the agent can expect as a result, making the context incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both parameters (title and sheets) fully described in the input schema. The description adds no extra meaning about parameters, such as constraints or behaviors, so the baseline of 3 is appropriate because the schema carries the full burden of parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create a new Google Sheets spreadsheet' clearly states the verb (create) and the resource (Google Sheets spreadsheet), which differentiates it from sibling tools like sheets_create_chart or sheets_insert_sheet. However, it does not explicitly elaborate on the scope or add value over the tool name, so it lacks the explicit sibling differentiation seen in top-tier examples.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as sheets_insert_sheet (for adding a sheet to an existing spreadsheet) or when not to use it. The description only states the action without any contextual usage instructions, leaving the agent to infer the appropriate situation from the schema and tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_delete_chartAIdempotent
Delete a chart from a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| chartId | Yes | The ID of the chart to delete (use sheets_get_metadata to find chart IDs) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotation idempotentHint=true already signals that repeated deletes are safe. The description adds no extra behavioral context, such as whether the chart must exist, permissions required, or irreversibility. With annotations present, the bar is lower, but the description still does not go beyond the literal action.
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?
The description is a single, focused sentence with no filler or redundant information. It conveys the purpose efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter deletion tool with no output schema and an idempotency annotation, the description is minimally adequate. However, it omits potential edge cases (e.g., behavior if the chart ID is invalid, whether deletion cascades to associated data). The shortcoming is modest, given the tool's simplicity, but it does not fully help the agent anticipate outcomes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters already explained. The chartId description even provides a hint to use sheets_get_metadata. The tool description itself adds no parameter insight beyond what the schema provides, so the baseline 3 applies.
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?
The description uses a specific verb ('Delete') and resource ('chart from a Google Sheets spreadsheet'), clearly distinguishing it from siblings like sheets_create_chart and sheets_update_chart. It is unambiguous and action-oriented.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states what the tool does but gives no explicit guidance on when to use it versus alternatives. The context of deleting a chart is clear from the name, but there is no mention of prerequisites, such as the chart belonging to the given spreadsheet, or exclusions. No comparison with sibling tools is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_delete_columnsAIdempotent
Delete one or more columns from a Google Sheet using a full-column A1 range
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | Full-column A1 range to delete (e.g., "Sheet1!B:D" or "Sheet1!C:C"). If sheet name is omitted, the first sheet is used | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only include idempotentHint; no destructiveHint is provided. The description says 'Delete' but does not disclose consequences such as permanent data removal, shifting of remaining columns, or required permissions. This leaves a significant gap for a mutating operation.
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?
The description is a single, front-loaded sentence with a specific verb and resource. It is concise and free of filler, elegantly covering the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with two fully described parameters, an idempotency hint, and no output schema, the description covers the essential purpose and scope. It does not discuss side effects, but given the low complexity, the core information is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the parameter descriptions in the schema are already detailed (e.g., range example and spreadsheetId explanation). The tool description adds no extra parameter-level meaning beyond repeating the 'full-column A1 range' concept present in the schema.
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?
The description clearly states the action ('Delete'), resource ('columns from a Google Sheet'), and the specific method ('using a full-column A1 range'). It distinguishes from sibling tools like sheets_delete_rows and sheets_delete_sheet by specifying column deletion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for deleting columns and emphasizes the full-column range format, but it does not explicitly discuss when to use this tool versus alternatives (e.g., delete_rows, delete_sheet). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_delete_rowsBIdempotent
Delete one or more rows from a Google Sheet using a full-row A1 range
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | Full-row A1 range to delete (e.g., "Sheet1!2:4" or "Sheet1!3:3"). If sheet name is omitted, the first sheet is used | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.3/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only include idempotentHint: true, with no destructiveHint. The description does not disclose permanent deletion, row shifts, or permission requirements. The verb 'Delete' implies destructiveness, but no additional behavioral context is provided.
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?
A single, front-loaded sentence that conveys the essential operation and input format with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple delete tool, but lacks usage differentiation and side-effect disclosure. Given many sibling delete-related tools, more context about selection criteria and consequences would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters (range and spreadsheetId) already well-documented. The description adds no extra meaning beyond what the schema provides, so baseline 3 is appropriate.
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?
Description uses a specific verb ('Delete') with a clear resource ('rows from a Google Sheet') and specifies the input format ('full-row A1 range'). This clearly distinguishes it from sibling tools like sheets_delete_columns or sheets_delete_sheet.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool instead of alternatives such as sheets_delete_columns, sheets_delete_sheet, or sheets_clear_values. It does not mention prerequisites or context for choosing this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_delete_sheetBIdempotent
Delete a sheet from a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetId | Yes | The ID of the sheet to delete (use sheets_get_metadata to find sheet IDs) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the idempotentHint annotation, the description adds no additional behavioral context. It does not disclose that deletion is permanent, irreversible, or requires specific permissions. For a mutation tool, this is a significant gap.
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?
The description is a single sentence that is direct and without redundancy. Every word contributes to understanding the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with two well-documented parameters and no output schema. The description, while minimal, is sufficient for the core operation. However, it could be slightly more complete by mentioning the single-sheet scope or the permanence of deletion.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both parameters having detailed descriptions. The tool description adds no extra parameter semantics, but the schema already carries the burden, so a baseline of 3 is appropriate.
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?
The description uses a specific verb+resource construction ('Delete a sheet from a Google Sheets spreadsheet') that clearly states the tool's action and distinguishes it from sibling tools like sheets_delete_chart or sheets_delete_table.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention that this is for a single sheet while sheets_batch_delete_sheets handles multiple sheets, nor does it specify prerequisites like access requirements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_delete_tableAIdempotent
Delete a native Google Sheets table by tableId
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| tableId | Yes | The ID of the table to delete | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral details beyond the verb 'delete' and the idempotentHint annotation. It does not mention that deletion is permanent, whether write permissions are required, what happens to associated data, or potential errors. For a destructive operation, this is a significant transparency gap.
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?
The description is a single, concise sentence with no filler. It states the essential action and method, earning full marks for efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive delete tool with no output schema, the description omits important context: return behavior, error conditions, permission requirements, and irreversibility. The single sentence is too minimal to fully equip an agent, especially given the annotation only covers idempotency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for both parameters. The description essentially restates 'by tableId', adding no new semantic information beyond what the schema already provides. Baseline 3 is appropriate given the schema's completeness.
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?
The description 'Delete a native Google Sheets table by tableId' clearly states the action (delete), the resource (native Google Sheets table), and the identifying method (by tableId). This distinguishes it from sibling tools like sheets_delete_sheet and sheets_delete_chart, which target different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies this tool is for deleting tables (not sheets or charts) and specifies the identifying parameter. It does not explicitly mention alternatives or exclusions, but the resource type is unambiguous, and the context makes it clear when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_duplicate_sheetAIdempotent
Duplicate a sheet within a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetId | Yes | The ID of the sheet to duplicate (use sheets_get_metadata to find sheet IDs) | |
| newSheetName | No | The name for the duplicated sheet | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| insertSheetIndex | No | The index where the new sheet should be inserted (0-based) |
TDQS
A3.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false. The description adds minimal context beyond that: it states the operation is within the same spreadsheet, which is useful but does not clarify behavior like whether the original is preserved or what happens with existing data. No contradiction with annotations is present.
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?
The description is a single, direct sentence with no filler or redundancy. It immediately conveys the core purpose and is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description and schema cover the basic operation and parameters, but there is no output schema and no mention of edge cases (e.g., default new sheet name if not provided, behavior when the sheet name already exists). Given the tool's simplicity and annotation coverage, this is adequate but not rich.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage of parameters, each with its own description. The tool description adds no additional parameter context, but since the schema already fully documents the parameters, a baseline score of 3 is appropriate.
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?
The description clearly states the action (duplicate), the resource (a sheet), and the context (within a Google Sheets spreadsheet). It is specific and distinct from sibling tools like 'sheets_insert_sheet' (creates an empty sheet) and 'sheets_copy_to' (copies to another spreadsheet).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (when you want to duplicate a sheet) but does not provide explicit guidance on when to choose this over alternatives, nor does it mention any prerequisites or exclusions. Sibling tools such as sheets_insert_sheet and sheets_copy_to exist, but no comparative guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_format_cellsCIdempotent
Format cells in a Google Sheet (colors, fonts, alignment, number formats)
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | ||
| format | Yes | ||
| spreadsheetId | Yes |
TDQS
C2.7/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations showing idempotentHint=true and destructiveHint=false, the description adds no additional behavioral context. It fails to disclose what happens to existing formatting, whether the operation overrides all styles or just specified ones, or any permission requirements. The description only restates what the tool does without deeper behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, consisting of one sentence that front-loads the primary purpose and examples of formatting types. No redundant information is present, making it efficient to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity—a deeply nested format object, numerous enum options, and no output schema—the description is severely under-specified. It does not cover how the format object should be structured, the meaning of different color fields, or behavioral details like whether existing partial formatting is preserved. The lack of any examples or parameter explanations makes it inadequate for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain the meaning or expected usage of any parameters. While the schema is rich with nested objects and enums, the description provides no additional clarity (e.g., how to specify colors or number formats). The brief mention of format categories gives only a high-level hint of the format object's contents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it formats cells in a Google Sheet and lists specific formatting categories (colors, fonts, alignment, number formats). It distinguishes the general purpose from siblings like sheets_batch_format_cells, though it doesn't explicitly differentiate between single and batch operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as sheets_batch_format_cells or sheets_update_borders. There is no mention of prerequisites, limitations, or context where a different formatting tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_basic_filterARead-onlyIdempotent
Read the Basic Filter (AutoFilter) configuration for a sheet, including the filtered range, sort specs, and per-column filter criteria (hidden values, conditions, color filters). Returns hasBasicFilter: false if no filter is applied.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds useful behavioral detail by specifying exactly what data is returned and the sentinel behavior 'Returns hasBasicFilter: false if no filter is applied,' which goes beyond the annotations.
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?
The description is a single, front-loaded sentence that packages the verb, target, key data components, and a useful edge-case return value. Every phrase earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description takes on the burden of explaining return contents, and it does so for the main use case (filter config and hasBasicFilter flag). It is complete enough for a read-only, two-parameter tool, though it could mention behavior for invalid sheet names or permissions, but that is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with clear descriptions for spreadsheetId and sheetName, so the baseline is 3. The description does not add meaningful parameter details, but it does not need to since the schema is complete and unambiguous.
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?
The description starts with a specific verb+resource: 'Read the Basic Filter (AutoFilter) configuration for a sheet,' which clearly identifies the tool's function. It also lists concrete components (filtered range, sort specs, per-column criteria) and distinguishes it from sibling tools that handle other sheet aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when you need AutoFilter configuration) but does not explicitly contrast it with alternatives like sheets_get_full_sheet_snapshot or sheets_get_sheet_structure. No 'when not to use' or exclusionary guidance is provided, so it is adequate but not strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_border_mapARead-onlyIdempotent
Returns a visual tabular map of borders for a range. Instead of per-cell JSON with 4 separate border objects, returns compact grids showing which cells have top/bottom/left/right borders and their styles. Solves the ambiguity between "right border of cell N" vs "left border of cell N+1". Output: a horizontal-lines grid and a vertical-lines grid, each as a 2D array of line styles. Set includeStyle:true to include color and width details (larger output).
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | Range with sheet prefix, e.g. "Sheet1!A1:F10". Sheet name is required to resolve the range correctly. | |
| includeStyle | No | Default: false. When true, each border line includes color and width details. When false, only the style name (SOLID, DASHED, etc.) is shown — more compact. | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4.3/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior. The description adds valuable context about the output format (horizontal and vertical grids), the style detail controlled by includeStyle, and the larger output size. This goes beyond the annotations and helps set expectations.
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?
The description is compact, front-loaded with the core purpose, and every sentence adds value (output format, ambiguity solving, option effects). No wasted words or redundancy with schema details.
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 a simple read-only getter with no output schema, the description sufficiently explains what is returned (two 2D arrays), the meaning of the grids, and the effect of includeStyle. It also clarifies the range requirement indirectly via the schema. No major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already well-documented. The description adds only marginal detail (e.g., 'larger output' for includeStyle), which is not essential given the schema. Baseline of 3 is appropriate because the schema shoulders the burden.
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?
The description clearly states the tool's function: 'Returns a visual tabular map of borders for a range.' It also explains the compact grid format and the ambiguity it resolves, which distinguishes it from generic border getters. The verb 'returns' and resource 'borders for a range' make the purpose precise and differentiate it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides strong context by explaining that it overcomes the right/left border ambiguity and offers a compact alternative to per-cell JSON. However, it does not explicitly name alternative tools or state when not to use it, so it lacks explicit exclusions or named alternatives needed for a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_conditional_formattingARead-onlyIdempotent
Read conditional formatting rules and banded ranges (alternating row/column colors) for a sheet. CF formulas are normalized to English locale (semicolons → commas) by default. Each rule with a formula includes a "_formulaLocaleRaw" field with the original unmodified formula. Set normalizeFormulas:false to get raw formulas as returned by the API.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| normalizeFormulas | No | Default: true. Normalize formula separators to English locale (semicolons → commas). Each normalized rule includes "_formulaLocaleRaw" with the original formula. Set to false to get formulas exactly as returned by the Google Sheets API. |
TDQS
A4.5/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent. The description adds significant extra detail: normalized formulas to English locale, inclusion of '_formulaLocaleRaw', and the option to disable normalization. This goes beyond annotations and explains important behavior.
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?
Two sentences, front-loaded with the main purpose, and then a focused note on normalization. Every sentence earns its place without redundancy.
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 a read-only getter with no output schema, the description covers what is read (CF rules, banded ranges), default normalization, the raw locale field, and the escape hatch via parameter. It is complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with detailed descriptions for each parameter. The description reinforces the normalization behavior already in the schema but doesn't add new meaning beyond what the schema provides, so baseline 3 is appropriate.
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?
The description clearly states the tool reads conditional formatting rules and banded ranges, using a specific verb (Read) and resource. It distinguishes from siblings like 'sheet_get_sheet_formatting' by focusing on conditional formatting specifically.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context that this tool is for reading conditional formatting and banded ranges, and mentions the normalization behavior. Though it doesn't explicitly name alternatives, the scope is well-defined so an agent can infer when to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_data_validationARead-onlyIdempotent
Read data validation rules (checkboxes, dropdown lists, custom formulas, etc.) from a sheet or range. Returns a compact list of unique validation rules grouped by their cell ranges (run-length encoded). Useful for discovering checkboxes (BOOLEAN), dropdown lists (ONE_OF_LIST / ONE_OF_RANGE), number constraints, and custom formula validations.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | No | Optional range WITHOUT sheet prefix, e.g. "A1:Z85". If omitted, the entire sheet is inspected. | |
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4.2/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds substantial behavioral context: it returns a 'compact list of unique validation rules grouped by their cell ranges (run-length encoded)' and enumerates the validation categories it can detect. This goes beyond the annotations by explaining the return format and grouping logic, making the tool's behavior transparent. It doesn't cover error cases or pagination, but for a read-only tool this is sufficient.
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?
The description is two sentences long, front-loaded with the core purpose, then the return format, then the use cases. Every sentence adds distinct value: the first states what it does, the second explains output structure and applicability. There is no redundancy or filler, so it earns a perfect score for efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the moderate complexity (3 params, no output schema), the description adequately explains what the tool returns (compact list, run-length encoded, grouped by ranges) and why it's useful. It names the validation types it detects, providing a clear mental model. It doesn't provide an example output structure or edge cases, but for a read-only tool with stable annotations and a clear return description, this is complete enough for an agent to select and invoke correctly. Sibling tools don't overlap, so no context is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter (range, sheetName, spreadsheetId) clearly described in the schema. The description adds no extra parameter semantics beyond what the schema provides; it mentions 'sheet or range' but doesn't elaborate on parameter syntax or constraints. Since the schema already does the heavy lifting, a baseline score of 3 is appropriate.
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?
The description uses a specific verb 'Read' with a clear resource 'data validation rules' and scope 'from a sheet or range.' It distinguishes itself from sibling tools by naming specific validation types (checkboxes, dropdown lists), which no other sibling tool covers. This makes the tool's unique purpose immediately obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states it is 'Useful for discovering checkboxes (BOOLEAN), dropdown lists (ONE_OF_LIST / ONE_OF_RANGE), number constraints, and custom formula validations,' providing clear context for when to use. It doesn't explicitly state when not to use it or name alternatives, but the use cases are concrete enough to guide selection. No exclusions are mentioned, so this is a clear context without full alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_formatting_compactARead-onlyIdempotent
Returns cell formatting for a range as compact A1Range→format pairs. Adjacent cells with identical formatting are collapsed into rectangular ranges (run-length encoded). Reduces output by 90%+ compared to per-cell formatting for typical sheets. Use instead of sheets_get_full_sheet_snapshot when you only need formatting data. Supported fields: backgroundColor, backgroundColorStyle, textFormat, horizontalAlignment, verticalAlignment, wrapStrategy, textRotation, numberFormat, padding, borders.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | Range WITHOUT sheet prefix, e.g. "A1:Z85" | |
| fields | No | Optional list of format fields to include, e.g. ["backgroundColor", "textFormat", "borders"]. All supported fields returned if omitted. | |
| sheetName | Yes | Name of the sheet (tab) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| useEffectiveFormat | No | Use effectiveFormat (true, includes all inherited defaults) or userEnteredFormat (false, default — only explicit overrides). userEnteredFormat produces much smaller output. |
TDQS
A4.8/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly and idempotent annotations, the description discloses the output compression behavior (collapsing adjacent identical cells, 90%+ size reduction) and the supported format fields. This adds meaningful behavioral context not present in annotations.
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?
The description is concise and front-loaded: first sentence states purpose and output, second explains run-length encoding, third gives usage guidance, and fourth lists supported fields. Every sentence earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description adequately explains the return format (A1Range→format pairs with run-length encoding) and supported fields. It doesn't detail the exact JSON structure, but for a read-only formatting retrieval tool, this is sufficient. Slightly more detail on the pair structure could improve completeness, but it's already strong.
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 covers 100% of parameters, so baseline is 3. The description adds value by explicitly listing the allowed values for the 'fields' parameter (e.g., backgroundColor, textFormat), which supplements the schema's generic description. It also clarifies the compact output relates to parameter choices.
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?
The description clearly states the tool returns cell formatting as compact A1Range→format pairs, using run-length encoding. It distinguishes from sibling tools by recommending it over sheets_get_full_sheet_snapshot for formatting-only needs and lists supported fields.
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?
Explicit guidance is given: 'Use instead of sheets_get_full_sheet_snapshot when you only need formatting data.' This clearly indicates a use case and names an alternative, helping the agent select the right tool among many siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_full_sheet_snapshotARead-onlyIdempotent
One-shot tool: reads all structural and formatting metadata for a sheet in a single API call. Returns: sheet properties (frozen rows/cols, dimensions, tab color), merged cells, column widths, row heights, banded ranges, and optionally cell-level formatting for a specified range (includeFormattingRange). compactMode is OFF by default — full per-cell detail is returned unless compactMode:true is provided. When compactMode is ON, adjacent cells with identical formatting are collapsed into range descriptors (90%+ smaller output). Conditional formatting rules are included by default (includeConditionalFormatting:true); set to false to exclude them. CF formulas are normalized to English locale (commas). Use fields to limit which format properties are returned. Use this before programmatically recreating a sheet.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| fields | No | Optional list of format field names to include, e.g. ["backgroundColor", "textFormat", "borders"]. Reduces response size by excluding unused format properties. All fields returned if omitted. | |
| sheetName | Yes | Name of the sheet (tab) to snapshot | |
| compactMode | No | Default: false. Full per-cell formatting is returned unless compactMode:true is set. When true, adjacent cells with identical formatting are collapsed into range descriptors (run-length encoded), reducing output by 90%+ for typical formatted sheets. Only applies when includeFormattingRange is set. | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| useEffectiveFormat | No | If includeFormattingRange is set: use effectiveFormat (true) or userEnteredFormat (false, default). | |
| includeFormattingRange | No | Optional range WITHOUT sheet prefix (e.g. "A1:Z85") to include cell-level formatting. If omitted, only structural metadata is returned. | |
| includeConditionalFormatting | No | Default: true. Include conditional formatting rules and banded ranges in the snapshot. CF formulas are normalized to English locale (semicolons → commas). Set to false to reduce output size when CF rules are not needed. |
TDQS
A4.7/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint and idempotentHint, but the description goes far beyond by exposing defaults (compactMode OFF, includeConditionalFormatting true), output size implications of compactMode, and the locale normalization of CF formulas. This adds substantial behavioral context not available from annotations alone.
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?
The description is dense but well-structured: it starts with the overall purpose, lists return contents, then explains each option and its default. Every sentence contributes meaningful information without redundant filler, achieving high information density in a logical order.
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?
Despite lacking an output schema, the description thoroughly enumerates what is returned (sheet properties, merged cells, widths, heights, banded ranges, optional formatting) and covers all major behaviors (compact mode, conditional formatting, field filtering, locale normalization). For a tool with 7 parameters and no output schema, this is highly complete.
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 description coverage is 100%, so baseline is 3. The description adds value by explaining the purpose of fields limit, the effect of compactMode on output size, and the conditional formatting default, which complements but does not merely repeat schema descriptions. It slightly exceeds the baseline by clarifying parameter interactions.
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?
The description uses a specific verb ('reads') and resource ('all structural and formatting metadata for a sheet'), clearly distinguishing it from siblings like sheets_get_sheet_structure or sheets_get_sheet_formatting. It also explicitly frames it as a 'one-shot' comprehensive snapshot, which differentiates its scope from lighter getters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context and a primary use case: 'Use this before programmatically recreating a sheet.' It also explains when to enable compactMode or includeConditionalFormatting, but does not explicitly name alternative lighter tools or state when not to use this tool, falling just short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_merged_cellsARead-onlyIdempotent
Get all merged cell ranges for a specific sheet. Returns each merge as A1 notation and GridRange coordinates.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4.3/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only and idempotent behavior. The description adds the return format (A1 notation and GridRange coordinates), which is useful beyond the annotations. It does not discuss errors or empty results, but the safety profile is well covered.
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?
One concise, front-loaded sentence that states the operation and result format. Every word earns its place, with no fluff or redundancy.
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?
Given the low complexity, high schema coverage, and read-only annotations, the description fully covers the tool's purpose, scope, and return format. No output schema exists, but the return format disclosure is sufficient for this simple getter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for both parameters (spreadsheetId and sheetName), with clear descriptions. The tool description does not add extra parameter-specific meaning, but the schema already provides sufficient semantics, so the baseline of 3 is appropriate.
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?
The description clearly states the verb 'Get' and the resource 'merged cell ranges' with scope 'for a specific sheet'. It unambiguously distinguishes from sibling tools like sheets_merge_cells (action) and sheets_unmerge_cells.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case: to retrieve all merged ranges from a sheet. It does not explicitly mention alternatives or exclusions, but the purpose is clear enough that an agent can infer when to use it. The readOnlyHint annotation reinforces it as a safe inspection tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_metadataBRead-onlyIdempotent
Get metadata about a Google Sheets spreadsheet including sheet names, IDs, and properties
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.4/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds the contents of the metadata returned (sheet names, IDs, properties), which is useful but does not reveal any additional behavioral traits or edge cases.
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?
The description is a single, front-loaded sentence that conveys the core purpose without unnecessary words. It earns its place with specific detail about the returned metadata.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read-only tool with annotations, the description adequately explains what the tool returns. However, without an output schema, it could be more explicit about the exact structure or any additional metadata fields, leaving a small gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the spreadsheetId parameter well-documented in the schema. The tool description adds no extra meaning beyond the schema, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'get' and resource 'metadata about a Google Sheets spreadsheet', listing specific contents (sheet names, IDs, properties). It is not explicitly differentiated from siblings like sheets_get_sheet_structure, but the scope is sufficiently clear and distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as sheets_get_sheet_structure or sheets_get_values. The description only states what it does, without any context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_sheet_dimensionsARead-onlyIdempotent
Get column widths (pixelSize), row heights (pixelSize), hidden columns/rows, and frozen row/column counts for a sheet.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds the specific scope of returned data but does not disclose edge-case behaviors, error conditions, or system side effects. No contradiction with annotations.
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?
A single, tightly worded sentence that lists all returned elements without redundant phrases. It earns its place and is easily scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description enumerates the returned dimension data, which gives the agent a solid understanding of the tool's output. It does not specify the exact return format (e.g., arrays vs objects), but for this read-only tool with simple params, the description is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters (spreadsheetId, sheetName) are fully described in the input schema with 100% coverage. The description repeats no parameter details and adds no additional parameter-specific meaning, so the baseline 3 applies.
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?
The description uses a specific verb ('Get') and resource ('sheet dimensions') and enumerates the exact data returned (column widths, row heights, hidden rows/columns, frozen counts), clearly distinguishing it from sibling tools like get_sheet_structure or get_values.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (when you need dimension info), but it does not name alternatives or specify when not to use it. No explicit guidance on choosing between this and similar tools like sheets_get_sheet_structure.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_sheet_formattingARead-onlyIdempotent
Read cell formatting (background color, text color, font family, font size, bold, italic, horizontal/vertical alignment, wrapStrategy, textRotation, numberFormat) for a range. Returns a 2D array matching the requested range rows/columns. Set useEffectiveFormat=true to get the resolved/inherited format instead of the user-entered one.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | Range in A1 notation, MUST include sheet name, e.g. "Dyspozycje!A1:Z85" | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| useEffectiveFormat | No | If true, returns effectiveFormat (includes inherited/default styles). Default: false (userEnteredFormat only). |
TDQS
A4.2/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the safety profile is known. The description adds value by disclosing the return shape (2D array) and the distinction between effective and user-entered format, which are behavioral details not present in annotations.
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?
Two tightly worded sentences. The first sentence front-loads the purpose and lists attributes, the second explains the return array and a key parameter tip. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only formatting getter with good annotations and a simple parameter set, the description sufficiently covers the return format and the effective-format option. It could mention edge cases like empty cells, but given the tool's scope, the description is complete enough.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents all three parameters (100% coverage), so the baseline is 3. The description adds a list of formatting attributes and return behavior, but this is more about output than parameter syntax or semantics, so it does not significantly elevate the score.
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?
The description uses the specific verb 'Read' and clearly identifies the resource as 'cell formatting for a range,' listing attributes like background color, font, and alignment. This distinguishes it from siblings like sheets_get_values (which reads values) and sheets_get_formatting_compact (which likely returns a compact view).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys clear context for when to use the tool (when formatting is needed) and gives a specific guideline for the useEffectiveFormat parameter. It does not explicitly compare to alternative tools, but the purpose is unambiguous enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_sheet_structureARead-onlyIdempotent
Lightweight tool returning ONLY structural/dimensional metadata for a sheet — no per-cell data. Returns: sheet dimensions, frozen rows/cols, tab color, sheet index, column widths array, row heights array, hidden columns/rows, and all merge ranges in A1 notation. Use this instead of sheets_get_full_sheet_snapshot when per-cell formatting is not needed. Much faster and cheaper — single API call with minimal field mask.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | Yes | Name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4.7/5.0
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already show readOnlyHint and idempotentHint, and the description adds valuable behavioral context beyond that: it explicitly states 'no per-cell data', lists all types of metadata returned, and reveals implementation traits like 'single API call with minimal field mask' and 'much faster and cheaper'. No contradiction with annotations.
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?
The description is concise and well-structured: it front-loads the primary purpose, follows with a detailed list of what is returned, then closes with usage guidance and performance context. All sentences contribute meaningful information without unnecessary fluff.
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?
Given the tool's simplicity (2 parameters, no output schema), the description is remarkably complete. It specifies return values, usage context, performance characteristics, and explicitly states what it does NOT return (per-cell data). This fully compensates for the absence of an output schema and covers the tool's complexity well.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and both parameters are fully described in the schema. The description does not add additional semantics for parameters, but per the rubric, the high schema coverage means the baseline is 3 and the description is not required to repeat parameter details.
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?
The description clearly states the tool's purpose: returning ONLY structural/dimensional metadata for a sheet, and it lists the specific metadata items returned. It also distinguishes itself from a sibling tool (sheets_get_full_sheet_snapshot) by explicitly noting it excludes per-cell data, making it highly specific and differentiated.
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?
The description provides explicit usage guidance: 'Use this instead of sheets_get_full_sheet_snapshot when per-cell formatting is not needed.' It also highlights performance benefits ('Much faster and cheaper'), giving the agent clear criteria for selecting this tool over an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_tablesBRead-onlyIdempotent
Read native Google Sheets tables for a spreadsheet or a specific sheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| sheetName | No | Optional name of the sheet (tab) to inspect | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.3/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds no behavioral context beyond the action itself, such as what constitutes a 'native table', whether it returns table metadata, or how it handles sheets without tables.
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?
A single sentence that is front-loaded and free of filler. It earns its place by defining the tool's scope and purpose efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with two well-documented parameters and readOnly annotations, the description is adequate but leaves ambiguity around the term 'native Google Sheets tables' and does not clarify what output to expect. More detail on the object being read would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both spreadsheetId and sheetName fully described in the schema. The description loosely references these parameters ('for a spreadsheet or a specific sheet') but adds no additional meaning beyond that.
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?
The description clearly states the action ('Read') and the resource ('native Google Sheets tables') with a scoping phrase ('for a spreadsheet or a specific sheet'). This distinguishes it from sibling tools like sheets_get_values (reads cell values) and sheets_get_sheet_structure (reads sheet layout).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives. It does not mention cases where other tools (e.g., sheets_get_values or sheets_get_sheet_structure) would be more appropriate, and no exclusions are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_get_valuesBRead-onlyIdempotent
Get values from a specified range in a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | The A1 notation range to retrieve (e.g., "Sheet1!A1:B10") | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| majorDimension | No | The major dimension of the values (default: ROWS) | |
| valueRenderOption | No | How values should be represented (default: FORMATTED_VALUE) |
TDQS
B3.2/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds no additional behavioral context (e.g., return format, pagination, or default behaviors) beyond what the name and schema imply.
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?
The description is a single, efficient sentence that gets straight to the point. It is front-loaded with the action and resource, with no wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only getter, the description, combined with the complete schema and annotations, provides sufficient information. It could benefit from a note about using non-batch retrieval vs batch, but the tool is straightforward enough that this is not a critical gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of the parameters, so the baseline is 3. The tool description does not add any extra semantics beyond the schema; all parameters are already well-documented with type and examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (get values) and resource (specified range in a Google Sheets spreadsheet). It is unambiguous and functionally specific, but it does not explicitly distinguish itself from the sibling tool 'sheets_batch_get_values', which might offer multi-range retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like sheets_batch_get_values or sheets_get_sheet_structure. The description simply states what it does without contextual usage clues or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_insert_dateAIdempotent
Insert properly formatted dates in Google Sheets with locale support and automatic detection
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| date | Yes | Date to insert (supports various formats: YYYY-MM-DD, DD.MM.YYYY, MM/DD/YYYY, or relative dates like "today", "tomorrow") | |
| range | Yes | The A1 notation range to insert the date (e.g., "Sheet1!A1") | |
| format | No | Date format preference (locale=spreadsheet locale, iso=YYYY-MM-DD, us=MM/DD/YYYY, eu=DD.MM.YYYY) | locale |
| autoDetect | No | Automatically detect and parse date format (default: true) | |
| useEUFormat | No | Use semicolon separator for EU locale sheets (auto-detected from user language/context if not specified) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A4/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, covering safety and repeatability. The description adds behavioral context about automatic detection and locale support, but does not disclose what happens to existing cell contents or how formatting is applied. This adds some value beyond annotations without contradiction.
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?
The description is a single, concise sentence that front-loads the primary action and key differentiators. Every word earns its place with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters and no output schema, the description plus rich schema provides adequate context for basic use. It does not clarify multi-cell range behavior or return values, but the tool's purpose is simple and the schema covers all parameters. Given moderate complexity, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters (date, range, format, autoDetect, useEUFormat, spreadsheetId) are documented. The description's mention of 'locale support' and 'automatic detection' loosely aligns with format and autoDetect params, but it adds no new meaning beyond the schema. Baseline 3 is appropriate.
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?
The description clearly states the tool's function: 'Insert properly formatted dates in Google Sheets' with specific features like locale support and automatic detection. This verb+resource+feature structure distinguishes it from sibling tools like sheets_update_values or sheets_format_cells.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys the tool's niche—handling date insertion with locale awareness—but does not explicitly name alternative tools or when not to use them. The context is clear enough for an agent to select it for date-specific tasks, though it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_insert_linkBIdempotent
Insert clickable links in Google Sheets cells with custom display text
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The URL to link to (must be a valid URL) | |
| text | No | Custom display text for the link (optional - if not provided, the URL will be displayed) | |
| range | Yes | The A1 notation range to insert the link (e.g., "Sheet1!A1" or "A1:B2") | |
| validation | No | Whether to validate the URL format (default: true) | |
| useEUFormat | No | Use semicolon separator for EU locale sheets (auto-detected from user language/context if not specified) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.1/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare idempotentHint=true and destructiveHint=false, but the description adds no additional behavioral context. It doesn't explain that inserting a link may overwrite existing cell content, how validation behaves, or what happens if the range covers multiple cells. The description carries little weight beyond the annotations themselves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise, front-loaded sentence with no filler. However, it is extremely brief, and while it is efficient, it sacrifices informative details that could be structured into separate clauses. Still, for a simple, non-verbose description, it earns a high conciseness score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters, no output schema, and a one-sentence description, the tool is under-specified. The description fails to mention important parameters like validation or useEUFormat, and lacks guidance on how ranges work or what the function returns. The schema compensates partially, but the description alone is not enough for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description mentions 'custom display text,' which mirrors the 'text' parameter, but doesn't add new meaning beyond the schema's own parameter descriptions. No extra value is provided to help understand parameter interactions or formatting.
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?
The description clearly states the tool's action: 'Insert clickable links in Google Sheets cells with custom display text.' It uses a specific verb ('insert'), specifies the resource ('links in Google Sheets cells'), and describes the key feature (custom display text). This distinguishes it from sibling tools like sheets_update_values or sheets_format_cells.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or comparison to similar tools like sheets_update_values. The agent is left to infer usage solely from the name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_insert_rowsCIdempotent
Insert new rows at a specific position with optional data
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| rows | No | Number of rows to insert (default: 1) | |
| range | Yes | The A1 notation anchor point where rows will be inserted (e.g., "Sheet1!A5") | |
| values | No | Optional 2D array of values to fill the newly inserted rows | |
| position | No | Position relative to the anchor row (default: BEFORE) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| valueInputOption | No | How the input data should be interpreted (default: USER_ENTERED) | |
| inheritFromBefore | No | Whether to inherit formatting from the row before (default: false) |
TDQS
C2.9/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond the insert action itself, such as row shifting, formatting inheritance, or permission requirements. Annotations already indicate idempotent and non-destructive behavior, but the description fails to enrich them with any operational detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no filler or redundant information. It is concise but might benefit from structured addition of usage context; still, its brevity is effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 7 parameters, two enums, and no output schema, this one-liner fails to provide essential context such as how rows shift relative to the anchor, what happens to existing data, or how the tool behaves with defaults. The description is too sparse for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with descriptions for all 7 parameters, including enums for position and valueInputOption. The description's phrase 'optional data' adds little beyond the schema's 'values' parameter, so it does not meaningfully compensate or extend.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Insert' targeting 'rows' with 'at a specific position' and 'optional data', which clearly distinguishes the operation from append (values at end) and sheet-level insertion. However, it does not explicitly mention the anchor mechanism or sibling tool names, so it stops short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as sheets_append_values or sheets_insert_sheet. It does not state use cases, exclusions, or conditions, leaving the agent to infer usage from the name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_insert_sheetAIdempotent
Add a new sheet to an existing Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| index | No | The index where the sheet should be inserted (0-based) | |
| title | Yes | The title of the new sheet | |
| rowCount | No | Number of rows in the sheet (default: 1000) | |
| columnCount | No | Number of columns in the sheet (default: 26) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false. The description adds no further behavioral details (e.g., behavior on duplicate titles or side effects). It does not contradict the annotations, but it also does not enrich the agent's understanding beyond what annotations provide.
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?
The description is a single, well-structured sentence that states the core purpose without superfluous words. It is front-loaded with the action and object.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the full schema and annotations, the description provides sufficient context for a simple add-sheet operation. However, it does not mention optional parameters' effects or expected return value, though the schema partially covers this. It is complete enough for typical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 5 parameters are fully described in the schema (100% coverage), so the baseline applies. The description does not add extra meaning to the parameters, such as how index or rowCount affect the sheet.
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?
The description clearly states the action (add), the object (a new sheet), and the scope (existing spreadsheet), distinguishing it from creating a new spreadsheet. It is concise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case (adding a sheet to an existing spreadsheet) but does not explicitly mention alternatives or when not to use this tool. It lacks exclusions or comparative guidance against sibling tools like sheets_create_spreadsheet or sheets_duplicate_sheet.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_merge_cellsBIdempotent
Merge cells in a Google Sheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | ||
| mergeType | Yes | ||
| spreadsheetId | Yes |
TDQS
B3.3/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already provide idempotentHint and destructiveHint, so the description does not repeat that. However, it adds no additional behavioral context, such as what happens to cell values after merging or whether already-merged ranges are handled gracefully.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no filler or redundancy. It is appropriately short for a simple tool, though it could have used some of its brevity to add useful context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple three-parameter tool with annotations covering idempotency and destruction risk, the description is close to minimally viable. But it still omits important context about merge behavior, return/effect semantics, and parameter choices, so an agent has to infer nontrivial details from the schema and tool name.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not explain spreadsheetId, range format, or mergeType semantics. The schema provides parameter names and an enum, but the description does not compensate for the lack of parameter-level guidance.
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?
The description is concise but specific: it names the action ('merge') and the resource ('cells in a Google Sheet'). It is clearly distinguishable from the sibling tool sheets_unmerge_cells, so an agent can identify the intended operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use the tool or how to choose among MERGE_ALL, MERGE_COLUMNS, and MERGE_ROWS. There is no mention of when to prefer this over merging alternatives or related operations like unmerge or checking existing merges.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_unmerge_cellsCIdempotent
Unmerge cells in a Google Sheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | ||
| spreadsheetId | Yes |
TDQS
C2.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations include idempotentHint: true, which is already provided. The description adds no extra behavioral context (e.g., what happens to data in merged cells, whether partial overlaps are handled, or any side effects). With the annotation, the bar is lowered, but the description still provides little beyond the obvious. Score 2.
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?
The description is a single short sentence with no fluff. It is perfectly concise. Score 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, no parameter descriptions, and only an idempotent hint, the description provides minimal context. It doesn't explain behavior on partial merges, what happens if the range contains no merged cells, or whether it operates on all merges overlapping the range. For a simple tool it might suffice, but given the lack of schema docscasions, it's incomplete. Score 1.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the tool description does not mention spreadsheetId or range at all. It doesn't explain what the range means (must it cover the entire merged region? partial ranges allowed?), nor does it add any guidance. Since coverage is 0%, the description must compensate but fails. Score 1.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Unmerge cells in a Google Sheet' clearly states the verb (unmerge) and resource (cells in a Google Sheet). It is specific enough to distinguish from siblings like sheets_merge_cells. However, it lacks any detail about scope or edge cases, so it doesn't fully differentiate from potential similar operations. Score 4.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool, what the range should represent, or any prerequisites (e.g., whether the range must exactly match a merged range). It doesn't mention alternatives or contrast with related tools. Score 2.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_update_bordersCIdempotent
Update borders of cells in a Google Sheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | ||
| borders | Yes | ||
| spreadsheetId | Yes |
TDQS
C2.6/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations idempotentHint:true and destructiveHint:false already declaring the safety profile, the description adds no behavioral context beyond what's in the annotation. It doesn't disclose that calling this tool overwrites existing border formatting on the range, or that style:NONE removes borders, which is critical behavioral knowledge for a tool that does full replacement of border settings.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
At nine words, there's no wasted language and the core action is front-loaded. However, it's so minimal that it reads as merely a grammatical expansion of the tool name rather than a thoughtfully concise description. Concise writing is good, but this egregiously under-uses the available space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameter with complex nested object semantics and no output schema, the description is inadequate. It fails to explain border replacement/overwrite semantics, how to remove borders, the color format specification, or the fact that the borders parameter is flexible. The sibling sheets_get_border_map could have been cross-referenced to complete the picture.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description was responsible for compensating, but it provides zero parameter guidance. The 'range' parameter's format (A1 notation) is never mentioned, and the borders object's per-side structure (top/left/right/bottom/innerHorizontal/innerVertical) and color semantics are left entirely to schema inference. The RGBA color object format and width constraints are particularly non-obvious without documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource structure ('Update borders of cells in a Google Sheet') that clearly conveys what the tool does. It doesn't explicitly distinguish itself from potentially overlapping siblings like sheets_format_cells (which might also touch borders), but the intent is immediately apparent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives such as sheets_format_cells, sheets_get_border_map, or batch operations. No preconditions (e.g., spreadsheet permissions), range format expectations, or notes about how it differs from the format_cells siblings are provided. The agent must infer usage entirely from the name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_update_chartAIdempotent
Update an existing chart in a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | Updated chart title (optional) | |
| legend | No | Updated legend configuration (optional) | |
| series | No | Updated array of data series for the chart (optional) | |
| altText | No | Updated alternative text for accessibility (optional) | |
| chartId | Yes | The ID of the chart to update (use sheets_get_metadata to find chart IDs) | |
| leftAxis | No | Updated left (Y) axis configuration (optional) | |
| position | No | Updated chart position settings (optional) | |
| subtitle | No | Updated chart subtitle (optional) | |
| chartType | No | Updated chart type (optional) | |
| rightAxis | No | Updated right (Y) axis configuration (optional) | |
| domainAxis | No | Updated domain (X) axis configuration (optional) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| backgroundColor | No | Updated chart background color (optional) |
TDQS
A3.7/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds only that the chart must exist ('existing'), but it does not disclose important update semantics such as whether omitted optional fields reset or preserve existing values. No contradiction with annotations.
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?
The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes meaning, and it is immediately clear what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although the schema and annotations provide substantial detail, the description is very thin for a complex 13-parameter tool with nested objects. It does not clarify update semantics (partial merge vs. full replacement), error behavior for non-existent charts, or return values (no output schema exists). The description is minimally viable but leaves important behavioral gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% with descriptive text for all 13 parameters, including enums and usage hints (e.g., chartId references sheets_get_metadata). The tool description itself adds no parameter-level insight, so the baseline 3 is appropriate.
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?
The description 'Update an existing chart in a Google Sheets spreadsheet' uses a specific verb ('Update') and resource ('chart'), and the word 'existing' clearly distinguishes it from sheets_create_chart. It is concise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for modifying an already-existing chart, but it does not explicitly state when to use this tool versus create/delete alternatives. The chartId parameter description does mention using sheets_get_metadata to find chart IDs, providing some operational guidance, but no explicit 'when not to use' is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_update_sheet_propertiesAIdempotent
Update properties of a sheet in a Google Sheets spreadsheet
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| title | No | New title for the sheet | |
| sheetId | Yes | The ID of the sheet to update (use sheets_get_metadata to find sheet IDs) | |
| tabColor | No | Tab color (RGB values from 0.0 to 1.0) | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| gridProperties | No | Grid properties to update |
TDQS
A3.8/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint and destructiveHint, covering the safety profile. The description adds no further behavioral context, such as whether only specified properties are updated (partial update) or how the API responds. It doesn't contradict annotations, but also doesn't disclose the patch semantics, which is useful for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It is concise and to the point, though it could have included slightly more context without becoming verbose. Every word is necessary, but it's minimal in content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters (including nested objects) and no output schema, the description is quite thin. It doesn't explain the partial-update behavior or what the API returns. However, with comprehensive schema descriptions and annotations, the agent can still use it correctly for basic property updates, but important behavioral gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter (spreadsheetId, sheetId, title, tabColor, gridProperties) has its own description. The tool description does not add additional meaning beyond the schema, so the baseline of 3 applies since the schema already provides the necessary semantics.
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?
The description 'Update properties of a sheet in a Google Sheets spreadsheet' clearly states the action (update) and the resource (sheet properties), distinguishing it from sibling tools that update values, format cells, or manage charts. The verb and resource are specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context: use this tool to modify sheet-level properties (title, tab color, grid properties) in a spreadsheet. While it doesn't explicitly rule out alternatives, the operation is unique among siblings (there is no other 'update properties' tool), so the usage context is clear enough without exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_update_tableBIdempotent
Update an existing native Google Sheets table by tableId
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Optional new table name | |
| range | No | Optional new A1 notation range for the table, e.g. "A1:D20" | |
| fields | Yes | Required field mask for the table update, e.g. "name", "range", "columnProperties", or "name,range" | |
| columns | No | Optional replacement column definitions for the table | |
| tableId | Yes | The ID of the table to update | |
| sheetName | No | Name of the target sheet when updating the table range | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) |
TDQS
B3.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already disclose idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the basic operation; it does not explain field mask semantics, that column definitions replace the entire table columns, or any side effects of the update.
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?
The description is a single, well-formed sentence with no filler. It is front-loaded with the verb 'Update' and clearly identifies the resource and key identifier (tableId). Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a moderately complex tool with 7 parameters and a required field mask, yet the description is only one sentence. It does not explain how the field mask selects which properties to update, nor that column definitions replace all columns. The schema provides parameter details, but the overall operation semantics are not conveyed, leaving the agent to infer critical behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already explains all parameters. The description itself adds no parameter-level meaning. Baseline of 3 is appropriate given complete schema coverage, but the description does not enhance understanding of field mask usage or parameter interactions.
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?
The description uses a specific verb and resource: 'Update an existing native Google Sheets table by tableId'. This clearly distinguishes the tool from siblings like sheets_add_table, sheets_delete_table, and sheets_get_tables, which correspond to other lifecycle operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The word 'existing' indicates this is for modifying tables that already exist, which implicitly differentiates it from creation tools. However, there is no explicit guidance on when to use this versus alternatives like sheets_add_table or sheets_get_tables, nor any mention of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sheets_update_valuesAIdempotent
Update values in a specified range of a Google Sheets spreadsheet. Examples:
Fixed range "A1:C3" - must provide exactly 3 rows
Flexible range "A1" - will expand to fit all provided rows
To update rows 42-74 (33 rows), use "A42" not "A42:E53" IMPORTANT: Empty rows in your data array still count as rows!
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| range | Yes | The A1 notation range to update. Use "Sheet1!A1:B10" for exact range (must match row count exactly) or "Sheet1!A1" for flexible range that auto-expands based on data. TIP: If updating multiple rows with varying content, use flexible range (e.g., "A42" instead of "A42:E53") to avoid row count mismatch errors. | |
| values | Yes | A 2D array of values to update, where each inner array represents a row | |
| spreadsheetId | Yes | The ID of the spreadsheet (found in the URL after /d/) | |
| valueInputOption | No | How the input data should be interpreted (default: USER_ENTERED) |
TDQS
A4.2/5.0
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true and destructiveHint=false. The description adds valuable behavioral context beyond these: row-count matching for fixed ranges, auto-expansion for flexible ranges, and the warning that empty rows in the data array still count as rows. This is significant practical information that annotations do not cover.
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?
The description is appropriately sized and front-loaded: one clear purpose sentence followed by three bullet-point examples and a critical warning. Every sentence earns its place, with no redundancy or filler. The structure makes the content easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the most critical usage nuances (fixed vs flexible ranges, row-count rules) that are not obvious from the schema or annotations. It does not mention return values, but the absence of an output schema and the mutation nature make that less essential. Overall, it gives an agent enough context to use the tool correctly in most scenarios.
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?
With 100% schema description coverage, the baseline is 3. The description enhances the parameter understanding with concrete examples for the 'range' parameter, such as avoiding 'A42:E53' and using 'A42' to prevent row-count mismatch errors. This goes beyond the schema's formal definition and gives the agent actionable guidance.
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?
The description clearly states the tool's function: 'Update values in a specified range of a Google Sheets spreadsheet.' The examples further clarify the exact behavior (fixed vs flexible ranges) and distinguish it from append/clear/read tools by focusing on overwriting existing cells.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides detailed usage examples and tips (e.g., using 'A42' for rows 42-74) but does not explicitly contrast with sibling tools like sheets_batch_update_values or sheets_append_values. When to choose this tool is implied rather than directly stated, leaving the agent to infer the differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v1.10.2- Changed
sheets_add_conditional_formatting7 fields changed- removed
Input schema / properties / rules / defRemoved value: -{ - "element": { - "def": { - "shape": { - "booleanRule": { - "def": { - "innerType": { - "def": { - "shape": { - "condition": { - "def": { - "shape": { - "type": { - "def": { - "entries": { - "BLANK": "BLANK", - "CUSTOM_FORMULA": "CUSTOM_FORMULA", - "NOT_BLANK": "NOT_BLANK", - "NUMBER_BETWEEN": "NUMBER_BETWEEN", - "NUMBER_EQ": "NUMBER_EQ", - "NUMBER_GREATER": "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS": "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", - "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", - "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", - "TEXT_CONTAINS": "TEXT_CONTAINS", - "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", - "TEXT_EQ": "TEXT_EQ", - "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" - }, - "type": "enum" - }, - "enum": { - "BLANK": "BLANK", - "CUSTOM_FORMULA": "CUSTOM_FORMULA", - "NOT_BLANK": "NOT_BLANK", - "NUMBER_BETWEEN": "NUMBER_BETWEEN", - "NUMBER_EQ": "NUMBER_EQ", - "NUMBER_GREATER": "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS": "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", - "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", - "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", - "TEXT_CONTAINS": "TEXT_CONTAINS", - "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", - "TEXT_EQ": "TEXT_EQ", - "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" - }, - "options": [ - "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ", - "NUMBER_EQ", - "NUMBER_NOT_EQ", - "NUMBER_BETWEEN", - "NUMBER_NOT_BETWEEN", - "TEXT_CONTAINS", - "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH", - "TEXT_ENDS_WITH", - "TEXT_EQ", - "BLANK", - "NOT_BLANK", - "CUSTOM_FORMULA" - ], - "type": "enum" - }, - "values": { - "def": { - "innerType": { - "def": { - "element": { - "def": { - "shape": { - "relativeDate": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "userEnteredValue": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "array" - }, - "element": { - "def": { - "shape": { - "relativeDate": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "userEnteredValue": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "array" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "format": { - "def": { - "shape": { - "backgroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "horizontalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "type": "enum" - }, - "enum": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "options": [ - "LEFT", - "CENTER", - "RIGHT" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "numberFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "pattern": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "type": { - "def": { - "entries": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "type": "enum" - }, - "enum": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "options": [ - "TEXT", - "NUMBER", - "PERCENT", - "CURRENCY", - "DATE", - "TIME", - "DATE_TIME", - "SCIENTIFIC" - ], - "type": "enum" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "padding": { - "def": { - "innerType": { - "def": { - "shape": { - "bottom": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "left": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "right": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "top": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "textFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "bold": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontFamily": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontSize": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "foregroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "italic": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "strikethrough": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "underline": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "verticalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "type": "enum" - }, - "enum": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "options": [ - "TOP", - "MIDDLE", - "BOTTOM" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "wrapStrategy": { - "def": { - "innerType": { - "def": { - "entries": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "type": "enum" - }, - "enum": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "options": [ - "OVERFLOW_CELL", - "LEGACY_WRAP", - "CLIP", - "WRAP" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "gradientRule": { - "def": { - "innerType": { - "def": { - "shape": { - "maxpoint": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "midpoint": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "minpoint": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "ranges": { - "def": { - "element": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "array" - }, - "element": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "array" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "array" -} - removed
Input schema / properties / rules / elementRemoved value: -{ - "def": { - "shape": { - "booleanRule": { - "def": { - "innerType": { - "def": { - "shape": { - "condition": { - "def": { - "shape": { - "type": { - "def": { - "entries": { - "BLANK": "BLANK", - "CUSTOM_FORMULA": "CUSTOM_FORMULA", - "NOT_BLANK": "NOT_BLANK", - "NUMBER_BETWEEN": "NUMBER_BETWEEN", - "NUMBER_EQ": "NUMBER_EQ", - "NUMBER_GREATER": "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS": "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", - "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", - "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", - "TEXT_CONTAINS": "TEXT_CONTAINS", - "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", - "TEXT_EQ": "TEXT_EQ", - "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" - }, - "type": "enum" - }, - "enum": { - "BLANK": "BLANK", - "CUSTOM_FORMULA": "CUSTOM_FORMULA", - "NOT_BLANK": "NOT_BLANK", - "NUMBER_BETWEEN": "NUMBER_BETWEEN", - "NUMBER_EQ": "NUMBER_EQ", - "NUMBER_GREATER": "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS": "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", - "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", - "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", - "TEXT_CONTAINS": "TEXT_CONTAINS", - "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", - "TEXT_EQ": "TEXT_EQ", - "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" - }, - "options": [ - "NUMBER_GREATER", - "NUMBER_GREATER_THAN_EQ", - "NUMBER_LESS", - "NUMBER_LESS_THAN_EQ", - "NUMBER_EQ", - "NUMBER_NOT_EQ", - "NUMBER_BETWEEN", - "NUMBER_NOT_BETWEEN", - "TEXT_CONTAINS", - "TEXT_NOT_CONTAINS", - "TEXT_STARTS_WITH", - "TEXT_ENDS_WITH", - "TEXT_EQ", - "BLANK", - "NOT_BLANK", - "CUSTOM_FORMULA" - ], - "type": "enum" - }, - "values": { - "def": { - "innerType": { - "def": { - "element": { - "def": { - "shape": { - "relativeDate": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "userEnteredValue": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "array" - }, - "element": { - "def": { - "shape": { - "relativeDate": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "userEnteredValue": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "array" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "format": { - "def": { - "shape": { - "backgroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "horizontalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "type": "enum" - }, - "enum": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "options": [ - "LEFT", - "CENTER", - "RIGHT" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "numberFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "pattern": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "type": { - "def": { - "entries": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "type": "enum" - }, - "enum": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "options": [ - "TEXT", - "NUMBER", - "PERCENT", - "CURRENCY", - "DATE", - "TIME", - "DATE_TIME", - "SCIENTIFIC" - ], - "type": "enum" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "padding": { - "def": { - "innerType": { - "def": { - "shape": { - "bottom": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "left": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "right": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "top": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "textFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "bold": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontFamily": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontSize": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "foregroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "italic": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "strikethrough": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "underline": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "verticalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "type": "enum" - }, - "enum": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "options": [ - "TOP", - "MIDDLE", - "BOTTOM" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "wrapStrategy": { - "def": { - "innerType": { - "def": { - "entries": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "type": "enum" - }, - "enum": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "options": [ - "OVERFLOW_CELL", - "LEGACY_WRAP", - "CLIP", - "WRAP" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "gradientRule": { - "def": { - "innerType": { - "def": { - "shape": { - "maxpoint": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "midpoint": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "minpoint": { - "def": { - "shape": { - "color": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": { - "def": { - "entries": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "type": "enum" - }, - "enum": { - "MAX": "MAX", - "MIN": "MIN", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "PERCENTILE": "PERCENTILE" - }, - "options": [ - "MIN", - "MAX", - "NUMBER", - "PERCENT", - "PERCENTILE" - ], - "type": "enum" - }, - "value": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "ranges": { - "def": { - "element": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "array" - }, - "element": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "array" - } - }, - "type": "object" - }, - "type": "object" -} - added
Input schema / properties / rules / itemsAdded value: +{ + "properties": { + "booleanRule": { + "properties": { + "condition": { + "properties": { + "type": { + "enum": [ + "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ", + "NUMBER_EQ", + "NUMBER_NOT_EQ", + "NUMBER_BETWEEN", + "NUMBER_NOT_BETWEEN", + "TEXT_CONTAINS", + "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH", + "TEXT_ENDS_WITH", + "TEXT_EQ", + "BLANK", + "NOT_BLANK", + "CUSTOM_FORMULA" + ], + "type": "string" + }, + "values": { + "items": { + "properties": { + "relativeDate": { + "type": "string" + }, + "userEnteredValue": { + "type": "string" + } + }, + "type": "object" + }, + "type": "array" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "format": { + "properties": { + "backgroundColor": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "horizontalAlignment": { + "enum": [ + "LEFT", + "CENTER", + "RIGHT" + ], + "type": "string" + }, + "numberFormat": { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "padding": { + "properties": { + "bottom": { + "type": "number" + }, + "left": { + "type": "number" + }, + "right": { + "type": "number" + }, + "top": { + "type": "number" + } + }, + "type": "object" + }, + "textFormat": { + "properties": { + "bold": { + "type": "boolean" + }, + "fontFamily": { + "type": "string" + }, + "fontSize": { + "exclusiveMinimum": 0, + "type": "number" + }, + "foregroundColor": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "italic": { + "type": "boolean" + }, + "strikethrough": { + "type": "boolean" + }, + "underline": { + "type": "boolean" + } + }, + "type": "object" + }, + "verticalAlignment": { + "enum": [ + "TOP", + "MIDDLE", + "BOTTOM" + ], + "type": "string" + }, + "wrapStrategy": { + "enum": [ + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "string" + } + }, + "type": "object" + } + }, + "required": [ + "condition", + "format" + ], + "type": "object" + }, + "gradientRule": { + "properties": { + "maxpoint": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "type": { + "enum": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "string" + }, + "value": { + "type": "string" + } + }, + "required": [ + "color", + "type" + ], + "type": "object" + }, + "midpoint": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "type": { + "enum": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "string" + }, + "value": { + "type": "string" + } + }, + "required": [ + "color", + "type" + ], + "type": "object" + }, + "minpoint": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "type": { + "enum": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "string" + }, + "value": { + "type": "string" + } + }, + "required": [ + "color", + "type" + ], + "type": "object" + } + }, + "required": [ + "minpoint", + "maxpoint" + ], + "type": "object" + }, + "ranges": { + "items": { + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "ranges" + ], + "type": "object" +} - removed
Input schema / properties / spreadsheetId / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / spreadsheetId / formatRemoved value: -null - removed
Input schema / properties / spreadsheetId / maxLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / minLengthRemoved value: -null
- Changed
sheets_format_cells10 fields changed- removed
Input schema / properties / format / defRemoved value: -{ - "shape": { - "backgroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "horizontalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "type": "enum" - }, - "enum": { - "CENTER": "CENTER", - "LEFT": "LEFT", - "RIGHT": "RIGHT" - }, - "options": [ - "LEFT", - "CENTER", - "RIGHT" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "numberFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "pattern": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "type": { - "def": { - "entries": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "type": "enum" - }, - "enum": { - "CURRENCY": "CURRENCY", - "DATE": "DATE", - "DATE_TIME": "DATE_TIME", - "NUMBER": "NUMBER", - "PERCENT": "PERCENT", - "SCIENTIFIC": "SCIENTIFIC", - "TEXT": "TEXT", - "TIME": "TIME" - }, - "options": [ - "TEXT", - "NUMBER", - "PERCENT", - "CURRENCY", - "DATE", - "TIME", - "DATE_TIME", - "SCIENTIFIC" - ], - "type": "enum" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "padding": { - "def": { - "innerType": { - "def": { - "shape": { - "bottom": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "left": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "right": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "top": { - "def": { - "innerType": { - "def": { - "checks": [], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": null, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "textFormat": { - "def": { - "innerType": { - "def": { - "shape": { - "bold": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontFamily": { - "def": { - "innerType": { - "def": { - "type": "string" - }, - "format": null, - "maxLength": null, - "minLength": null, - "type": "string" - }, - "type": "optional" - }, - "type": "optional" - }, - "fontSize": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "foregroundColor": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "italic": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "strikethrough": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - }, - "underline": { - "def": { - "innerType": { - "def": { - "type": "boolean" - }, - "type": "boolean" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "verticalAlignment": { - "def": { - "innerType": { - "def": { - "entries": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "type": "enum" - }, - "enum": { - "BOTTOM": "BOTTOM", - "MIDDLE": "MIDDLE", - "TOP": "TOP" - }, - "options": [ - "TOP", - "MIDDLE", - "BOTTOM" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - }, - "wrapStrategy": { - "def": { - "innerType": { - "def": { - "entries": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "type": "enum" - }, - "enum": { - "CLIP": "CLIP", - "LEGACY_WRAP": "LEGACY_WRAP", - "OVERFLOW_CELL": "OVERFLOW_CELL", - "WRAP": "WRAP" - }, - "options": [ - "OVERFLOW_CELL", - "LEGACY_WRAP", - "CLIP", - "WRAP" - ], - "type": "enum" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" -} - added
Input schema / properties / format / propertiesAdded value: +{ + "backgroundColor": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "horizontalAlignment": { + "enum": [ + "LEFT", + "CENTER", + "RIGHT" + ], + "type": "string" + }, + "numberFormat": { + "properties": { + "pattern": { + "type": "string" + }, + "type": { + "enum": [ + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "string" + } + }, + "required": [ + "type" + ], + "type": "object" + }, + "padding": { + "properties": { + "bottom": { + "type": "number" + }, + "left": { + "type": "number" + }, + "right": { + "type": "number" + }, + "top": { + "type": "number" + } + }, + "type": "object" + }, + "textFormat": { + "properties": { + "bold": { + "type": "boolean" + }, + "fontFamily": { + "type": "string" + }, + "fontSize": { + "exclusiveMinimum": 0, + "type": "number" + }, + "foregroundColor": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "italic": { + "type": "boolean" + }, + "strikethrough": { + "type": "boolean" + }, + "underline": { + "type": "boolean" + } + }, + "type": "object" + }, + "verticalAlignment": { + "enum": [ + "TOP", + "MIDDLE", + "BOTTOM" + ], + "type": "string" + }, + "wrapStrategy": { + "enum": [ + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "string" + } +} - removed
Input schema / properties / range / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / range / formatRemoved value: -null - removed
Input schema / properties / range / maxLengthRemoved value: -null - removed
Input schema / properties / range / minLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / spreadsheetId / formatRemoved value: -null - removed
Input schema / properties / spreadsheetId / maxLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / minLengthRemoved value: -null
- Changed
sheets_merge_cells12 fields changed- removed
Input schema / properties / mergeType / defRemoved value: -{ - "entries": { - "MERGE_ALL": "MERGE_ALL", - "MERGE_COLUMNS": "MERGE_COLUMNS", - "MERGE_ROWS": "MERGE_ROWS" - }, - "type": "enum" -} - changed
Input schema / properties / mergeType / enumPrevious value: -{ - "MERGE_ALL": "MERGE_ALL", - "MERGE_COLUMNS": "MERGE_COLUMNS", - "MERGE_ROWS": "MERGE_ROWS" -}New value: +[ + "MERGE_ALL", + "MERGE_COLUMNS", + "MERGE_ROWS" +] - removed
Input schema / properties / mergeType / optionsRemoved value: -[ - "MERGE_ALL", - "MERGE_COLUMNS", - "MERGE_ROWS" -] - changed
Input schema / properties / mergeType / typePrevious value: -"enum"New value: +"string" - removed
Input schema / properties / range / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / range / formatRemoved value: -null - removed
Input schema / properties / range / maxLengthRemoved value: -null - removed
Input schema / properties / range / minLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / spreadsheetId / formatRemoved value: -null - removed
Input schema / properties / spreadsheetId / maxLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / minLengthRemoved value: -null
- Changed
sheets_unmerge_cells8 fields changed- removed
Input schema / properties / range / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / range / formatRemoved value: -null - removed
Input schema / properties / range / maxLengthRemoved value: -null - removed
Input schema / properties / range / minLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / spreadsheetId / formatRemoved value: -null - removed
Input schema / properties / spreadsheetId / maxLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / minLengthRemoved value: -null
- Changed
sheets_update_borders10 fields changed- removed
Input schema / properties / borders / defRemoved value: -{ - "shape": { - "bottom": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "innerHorizontal": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "innerVertical": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "left": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "right": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "top": { - "def": { - "innerType": { - "def": { - "shape": { - "color": { - "def": { - "innerType": { - "def": { - "shape": { - "alpha": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "blue": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "green": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - }, - "red": { - "def": { - "innerType": { - "def": { - "checks": [ - {}, - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": 1, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - }, - "style": { - "def": { - "entries": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "type": "enum" - }, - "enum": { - "DASHED": "DASHED", - "DOTTED": "DOTTED", - "DOUBLE": "DOUBLE", - "NONE": "NONE", - "SOLID": "SOLID", - "SOLID_MEDIUM": "SOLID_MEDIUM", - "SOLID_THICK": "SOLID_THICK" - }, - "options": [ - "NONE", - "SOLID", - "DASHED", - "DOTTED", - "SOLID_MEDIUM", - "SOLID_THICK", - "DOUBLE" - ], - "type": "enum" - }, - "width": { - "def": { - "innerType": { - "def": { - "checks": [ - {} - ], - "type": "number" - }, - "format": null, - "isFinite": true, - "isInt": false, - "maxValue": null, - "minValue": 0, - "type": "number" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" - }, - "type": "object" - }, - "type": "optional" - }, - "type": "optional" - } - }, - "type": "object" -} - added
Input schema / properties / borders / propertiesAdded value: +{ + "bottom": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + }, + "innerHorizontal": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + }, + "innerVertical": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + }, + "left": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + }, + "right": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + }, + "top": { + "properties": { + "color": { + "properties": { + "alpha": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "blue": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "green": { + "maximum": 1, + "minimum": 0, + "type": "number" + }, + "red": { + "maximum": 1, + "minimum": 0, + "type": "number" + } + }, + "type": "object" + }, + "style": { + "enum": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "string" + }, + "width": { + "exclusiveMinimum": 0, + "type": "number" + } + }, + "required": [ + "style" + ], + "type": "object" + } +} - removed
Input schema / properties / range / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / range / formatRemoved value: -null - removed
Input schema / properties / range / maxLengthRemoved value: -null - removed
Input schema / properties / range / minLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / defRemoved value: -{ - "type": "string" -} - removed
Input schema / properties / spreadsheetId / formatRemoved value: -null - removed
Input schema / properties / spreadsheetId / maxLengthRemoved value: -null - removed
Input schema / properties / spreadsheetId / minLengthRemoved value: -null
5 tool updates
v1.10.1- Changed
sheets_add_conditional_formatting12 fields changed- removed
Input schema / properties / rules / _defRemoved value: -{ - "exactLength": null, - "maxLength": null, - "minLength": null, - "type": { - "_cached": null, - "_def": { - "catchall": { - "_def": { - "typeName": "ZodNever" - }, - "~standard": { - "vendor": "zod", - "version": 1 - } - }, - "typeName": "ZodObject", - "unknownKeys": "strip" - }, - "~standard": { - "vendor": "zod", - "version": 1 - } - }, - "typeName": "ZodArray" -} - added
Input schema / properties / rules / defAdded value: +{ + "element": { + "def": { + "shape": { + "booleanRule": { + "def": { + "innerType": { + "def": { + "shape": { + "condition": { + "def": { + "shape": { + "type": { + "def": { + "entries": { + "BLANK": "BLANK", + "CUSTOM_FORMULA": "CUSTOM_FORMULA", + "NOT_BLANK": "NOT_BLANK", + "NUMBER_BETWEEN": "NUMBER_BETWEEN", + "NUMBER_EQ": "NUMBER_EQ", + "NUMBER_GREATER": "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS": "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", + "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", + "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", + "TEXT_CONTAINS": "TEXT_CONTAINS", + "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", + "TEXT_EQ": "TEXT_EQ", + "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" + }, + "type": "enum" + }, + "enum": { + "BLANK": "BLANK", + "CUSTOM_FORMULA": "CUSTOM_FORMULA", + "NOT_BLANK": "NOT_BLANK", + "NUMBER_BETWEEN": "NUMBER_BETWEEN", + "NUMBER_EQ": "NUMBER_EQ", + "NUMBER_GREATER": "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS": "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", + "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", + "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", + "TEXT_CONTAINS": "TEXT_CONTAINS", + "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", + "TEXT_EQ": "TEXT_EQ", + "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" + }, + "options": [ + "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ", + "NUMBER_EQ", + "NUMBER_NOT_EQ", + "NUMBER_BETWEEN", + "NUMBER_NOT_BETWEEN", + "TEXT_CONTAINS", + "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH", + "TEXT_ENDS_WITH", + "TEXT_EQ", + "BLANK", + "NOT_BLANK", + "CUSTOM_FORMULA" + ], + "type": "enum" + }, + "values": { + "def": { + "innerType": { + "def": { + "element": { + "def": { + "shape": { + "relativeDate": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "userEnteredValue": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "array" + }, + "element": { + "def": { + "shape": { + "relativeDate": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "userEnteredValue": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "array" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "format": { + "def": { + "shape": { + "backgroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "horizontalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "type": "enum" + }, + "enum": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "options": [ + "LEFT", + "CENTER", + "RIGHT" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "numberFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "pattern": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "type": { + "def": { + "entries": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "type": "enum" + }, + "enum": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "options": [ + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "enum" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "padding": { + "def": { + "innerType": { + "def": { + "shape": { + "bottom": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "left": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "right": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "top": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "textFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "bold": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontFamily": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontSize": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "foregroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "italic": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "strikethrough": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "underline": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "verticalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "type": "enum" + }, + "enum": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "options": [ + "TOP", + "MIDDLE", + "BOTTOM" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "wrapStrategy": { + "def": { + "innerType": { + "def": { + "entries": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "type": "enum" + }, + "enum": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "options": [ + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "gradientRule": { + "def": { + "innerType": { + "def": { + "shape": { + "maxpoint": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "midpoint": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "minpoint": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "ranges": { + "def": { + "element": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "array" + }, + "element": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "array" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "array" +} - added
Input schema / properties / rules / elementAdded value: +{ + "def": { + "shape": { + "booleanRule": { + "def": { + "innerType": { + "def": { + "shape": { + "condition": { + "def": { + "shape": { + "type": { + "def": { + "entries": { + "BLANK": "BLANK", + "CUSTOM_FORMULA": "CUSTOM_FORMULA", + "NOT_BLANK": "NOT_BLANK", + "NUMBER_BETWEEN": "NUMBER_BETWEEN", + "NUMBER_EQ": "NUMBER_EQ", + "NUMBER_GREATER": "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS": "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", + "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", + "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", + "TEXT_CONTAINS": "TEXT_CONTAINS", + "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", + "TEXT_EQ": "TEXT_EQ", + "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" + }, + "type": "enum" + }, + "enum": { + "BLANK": "BLANK", + "CUSTOM_FORMULA": "CUSTOM_FORMULA", + "NOT_BLANK": "NOT_BLANK", + "NUMBER_BETWEEN": "NUMBER_BETWEEN", + "NUMBER_EQ": "NUMBER_EQ", + "NUMBER_GREATER": "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ": "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS": "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ": "NUMBER_LESS_THAN_EQ", + "NUMBER_NOT_BETWEEN": "NUMBER_NOT_BETWEEN", + "NUMBER_NOT_EQ": "NUMBER_NOT_EQ", + "TEXT_CONTAINS": "TEXT_CONTAINS", + "TEXT_ENDS_WITH": "TEXT_ENDS_WITH", + "TEXT_EQ": "TEXT_EQ", + "TEXT_NOT_CONTAINS": "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH": "TEXT_STARTS_WITH" + }, + "options": [ + "NUMBER_GREATER", + "NUMBER_GREATER_THAN_EQ", + "NUMBER_LESS", + "NUMBER_LESS_THAN_EQ", + "NUMBER_EQ", + "NUMBER_NOT_EQ", + "NUMBER_BETWEEN", + "NUMBER_NOT_BETWEEN", + "TEXT_CONTAINS", + "TEXT_NOT_CONTAINS", + "TEXT_STARTS_WITH", + "TEXT_ENDS_WITH", + "TEXT_EQ", + "BLANK", + "NOT_BLANK", + "CUSTOM_FORMULA" + ], + "type": "enum" + }, + "values": { + "def": { + "innerType": { + "def": { + "element": { + "def": { + "shape": { + "relativeDate": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "userEnteredValue": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "array" + }, + "element": { + "def": { + "shape": { + "relativeDate": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "userEnteredValue": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "array" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "format": { + "def": { + "shape": { + "backgroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "horizontalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "type": "enum" + }, + "enum": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "options": [ + "LEFT", + "CENTER", + "RIGHT" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "numberFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "pattern": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "type": { + "def": { + "entries": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "type": "enum" + }, + "enum": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "options": [ + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "enum" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "padding": { + "def": { + "innerType": { + "def": { + "shape": { + "bottom": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "left": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "right": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "top": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "textFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "bold": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontFamily": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontSize": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "foregroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "italic": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "strikethrough": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "underline": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "verticalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "type": "enum" + }, + "enum": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "options": [ + "TOP", + "MIDDLE", + "BOTTOM" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "wrapStrategy": { + "def": { + "innerType": { + "def": { + "entries": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "type": "enum" + }, + "enum": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "options": [ + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "gradientRule": { + "def": { + "innerType": { + "def": { + "shape": { + "maxpoint": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "midpoint": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "minpoint": { + "def": { + "shape": { + "color": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": { + "def": { + "entries": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "type": "enum" + }, + "enum": { + "MAX": "MAX", + "MIN": "MIN", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "PERCENTILE": "PERCENTILE" + }, + "options": [ + "MIN", + "MAX", + "NUMBER", + "PERCENT", + "PERCENTILE" + ], + "type": "enum" + }, + "value": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "ranges": { + "def": { + "element": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "array" + }, + "element": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "array" + } + }, + "type": "object" + }, + "type": "object" +} - added
Input schema / properties / rules / typeAdded value: +"array" - removed
Input schema / properties / rules / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / spreadsheetId / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / spreadsheetId / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / spreadsheetId / formatAdded value: +null - added
Input schema / properties / spreadsheetId / maxLengthAdded value: +null - added
Input schema / properties / spreadsheetId / minLengthAdded value: +null - added
Input schema / properties / spreadsheetId / typeAdded value: +"string" - removed
Input schema / properties / spreadsheetId / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -}
- Changed
sheets_format_cells19 fields changed- removed
Input schema / properties / format / _cachedRemoved value: -null - removed
Input schema / properties / format / _defRemoved value: -{ - "catchall": { - "_def": { - "typeName": "ZodNever" - }, - "~standard": { - "vendor": "zod", - "version": 1 - } - }, - "typeName": "ZodObject", - "unknownKeys": "strip" -} - added
Input schema / properties / format / defAdded value: +{ + "shape": { + "backgroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "horizontalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "type": "enum" + }, + "enum": { + "CENTER": "CENTER", + "LEFT": "LEFT", + "RIGHT": "RIGHT" + }, + "options": [ + "LEFT", + "CENTER", + "RIGHT" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "numberFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "pattern": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "type": { + "def": { + "entries": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "type": "enum" + }, + "enum": { + "CURRENCY": "CURRENCY", + "DATE": "DATE", + "DATE_TIME": "DATE_TIME", + "NUMBER": "NUMBER", + "PERCENT": "PERCENT", + "SCIENTIFIC": "SCIENTIFIC", + "TEXT": "TEXT", + "TIME": "TIME" + }, + "options": [ + "TEXT", + "NUMBER", + "PERCENT", + "CURRENCY", + "DATE", + "TIME", + "DATE_TIME", + "SCIENTIFIC" + ], + "type": "enum" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "padding": { + "def": { + "innerType": { + "def": { + "shape": { + "bottom": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "left": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "right": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "top": { + "def": { + "innerType": { + "def": { + "checks": [], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": null, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "textFormat": { + "def": { + "innerType": { + "def": { + "shape": { + "bold": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontFamily": { + "def": { + "innerType": { + "def": { + "type": "string" + }, + "format": null, + "maxLength": null, + "minLength": null, + "type": "string" + }, + "type": "optional" + }, + "type": "optional" + }, + "fontSize": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "foregroundColor": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "italic": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "strikethrough": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + }, + "underline": { + "def": { + "innerType": { + "def": { + "type": "boolean" + }, + "type": "boolean" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "verticalAlignment": { + "def": { + "innerType": { + "def": { + "entries": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "type": "enum" + }, + "enum": { + "BOTTOM": "BOTTOM", + "MIDDLE": "MIDDLE", + "TOP": "TOP" + }, + "options": [ + "TOP", + "MIDDLE", + "BOTTOM" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + }, + "wrapStrategy": { + "def": { + "innerType": { + "def": { + "entries": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "type": "enum" + }, + "enum": { + "CLIP": "CLIP", + "LEGACY_WRAP": "LEGACY_WRAP", + "OVERFLOW_CELL": "OVERFLOW_CELL", + "WRAP": "WRAP" + }, + "options": [ + "OVERFLOW_CELL", + "LEGACY_WRAP", + "CLIP", + "WRAP" + ], + "type": "enum" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" +} - added
Input schema / properties / format / typeAdded value: +"object" - removed
Input schema / properties / format / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / range / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / range / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / range / formatAdded value: +null - added
Input schema / properties / range / maxLengthAdded value: +null - added
Input schema / properties / range / minLengthAdded value: +null - added
Input schema / properties / range / typeAdded value: +"string" - removed
Input schema / properties / range / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / spreadsheetId / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / spreadsheetId / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / spreadsheetId / formatAdded value: +null - added
Input schema / properties / spreadsheetId / maxLengthAdded value: +null - added
Input schema / properties / spreadsheetId / minLengthAdded value: +null - added
Input schema / properties / spreadsheetId / typeAdded value: +"string" - removed
Input schema / properties / spreadsheetId / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -}
- Changed
sheets_merge_cells20 fields changed- removed
Input schema / properties / mergeType / _defRemoved value: -{ - "typeName": "ZodEnum", - "values": [ - "MERGE_ALL", - "MERGE_COLUMNS", - "MERGE_ROWS" - ] -} - added
Input schema / properties / mergeType / defAdded value: +{ + "entries": { + "MERGE_ALL": "MERGE_ALL", + "MERGE_COLUMNS": "MERGE_COLUMNS", + "MERGE_ROWS": "MERGE_ROWS" + }, + "type": "enum" +} - added
Input schema / properties / mergeType / enumAdded value: +{ + "MERGE_ALL": "MERGE_ALL", + "MERGE_COLUMNS": "MERGE_COLUMNS", + "MERGE_ROWS": "MERGE_ROWS" +} - added
Input schema / properties / mergeType / optionsAdded value: +[ + "MERGE_ALL", + "MERGE_COLUMNS", + "MERGE_ROWS" +] - added
Input schema / properties / mergeType / typeAdded value: +"enum" - removed
Input schema / properties / mergeType / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / range / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / range / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / range / formatAdded value: +null - added
Input schema / properties / range / maxLengthAdded value: +null - added
Input schema / properties / range / minLengthAdded value: +null - added
Input schema / properties / range / typeAdded value: +"string" - removed
Input schema / properties / range / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / spreadsheetId / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / spreadsheetId / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / spreadsheetId / formatAdded value: +null - added
Input schema / properties / spreadsheetId / maxLengthAdded value: +null - added
Input schema / properties / spreadsheetId / minLengthAdded value: +null - added
Input schema / properties / spreadsheetId / typeAdded value: +"string" - removed
Input schema / properties / spreadsheetId / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -}
- Changed
sheets_unmerge_cells14 fields changed- removed
Input schema / properties / range / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / range / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / range / formatAdded value: +null - added
Input schema / properties / range / maxLengthAdded value: +null - added
Input schema / properties / range / minLengthAdded value: +null - added
Input schema / properties / range / typeAdded value: +"string" - removed
Input schema / properties / range / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / spreadsheetId / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / spreadsheetId / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / spreadsheetId / formatAdded value: +null - added
Input schema / properties / spreadsheetId / maxLengthAdded value: +null - added
Input schema / properties / spreadsheetId / minLengthAdded value: +null - added
Input schema / properties / spreadsheetId / typeAdded value: +"string" - removed
Input schema / properties / spreadsheetId / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -}
- Changed
sheets_update_borders19 fields changed- removed
Input schema / properties / borders / _cachedRemoved value: -null - removed
Input schema / properties / borders / _defRemoved value: -{ - "catchall": { - "_def": { - "typeName": "ZodNever" - }, - "~standard": { - "vendor": "zod", - "version": 1 - } - }, - "typeName": "ZodObject", - "unknownKeys": "strip" -} - added
Input schema / properties / borders / defAdded value: +{ + "shape": { + "bottom": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "innerHorizontal": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "innerVertical": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "left": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "right": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "top": { + "def": { + "innerType": { + "def": { + "shape": { + "color": { + "def": { + "innerType": { + "def": { + "shape": { + "alpha": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "blue": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "green": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + }, + "red": { + "def": { + "innerType": { + "def": { + "checks": [ + {}, + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": 1, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + }, + "style": { + "def": { + "entries": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "type": "enum" + }, + "enum": { + "DASHED": "DASHED", + "DOTTED": "DOTTED", + "DOUBLE": "DOUBLE", + "NONE": "NONE", + "SOLID": "SOLID", + "SOLID_MEDIUM": "SOLID_MEDIUM", + "SOLID_THICK": "SOLID_THICK" + }, + "options": [ + "NONE", + "SOLID", + "DASHED", + "DOTTED", + "SOLID_MEDIUM", + "SOLID_THICK", + "DOUBLE" + ], + "type": "enum" + }, + "width": { + "def": { + "innerType": { + "def": { + "checks": [ + {} + ], + "type": "number" + }, + "format": null, + "isFinite": true, + "isInt": false, + "maxValue": null, + "minValue": 0, + "type": "number" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" + }, + "type": "object" + }, + "type": "optional" + }, + "type": "optional" + } + }, + "type": "object" +} - added
Input schema / properties / borders / typeAdded value: +"object" - removed
Input schema / properties / borders / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / range / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / range / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / range / formatAdded value: +null - added
Input schema / properties / range / maxLengthAdded value: +null - added
Input schema / properties / range / minLengthAdded value: +null - added
Input schema / properties / range / typeAdded value: +"string" - removed
Input schema / properties / range / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -} - removed
Input schema / properties / spreadsheetId / _defRemoved value: -{ - "checks": [], - "coerce": false, - "typeName": "ZodString" -} - added
Input schema / properties / spreadsheetId / defAdded value: +{ + "type": "string" +} - added
Input schema / properties / spreadsheetId / formatAdded value: +null - added
Input schema / properties / spreadsheetId / maxLengthAdded value: +null - added
Input schema / properties / spreadsheetId / minLengthAdded value: +null - added
Input schema / properties / spreadsheetId / typeAdded value: +"string" - removed
Input schema / properties / spreadsheetId / ~standardRemoved value: -{ - "vendor": "zod", - "version": 1 -}
4 tool updates
v1.9.0- Added
sheets_add_table - Added
sheets_delete_table - Added
sheets_get_tables - Added
sheets_update_table
24 tool updates
v1.8.1- Changed
sheets_append_values1 field changed- added
Input schema / properties / values / items / itemsAdded value: +{}
- Added
sheets_batch_delete_sheets - Added
sheets_batch_format_cells - Changed
sheets_batch_update_values1 field changed- added
Input schema / properties / data / items / properties / values / items / itemsAdded value: +{}
- Added
sheets_compare_ranges - Added
sheets_create_chart - Added
sheets_delete_chart - Added
sheets_delete_columns - Added
sheets_delete_rows - Added
sheets_get_basic_filter - Added
sheets_get_border_map - Added
sheets_get_conditional_formatting - Added
sheets_get_data_validation - Added
sheets_get_formatting_compact - Added
sheets_get_full_sheet_snapshot - Added
sheets_get_merged_cells - Added
sheets_get_sheet_dimensions - Added
sheets_get_sheet_formatting - Added
sheets_get_sheet_structure - Added
sheets_insert_date - Added
sheets_insert_link - Added
sheets_insert_rows - Added
sheets_update_chart - Changed
sheets_update_values1 field changed- added
Input schema / properties / values / items / itemsAdded value: +{}
19 tool updates
v1.0.0- First observed
sheets_add_conditional_formatting - First observed
sheets_append_values - First observed
sheets_batch_get_values - First observed
sheets_batch_update_values - First observed
sheets_check_access - First observed
sheets_clear_values - First observed
sheets_copy_to - First observed
sheets_create_spreadsheet - First observed
sheets_delete_sheet - First observed
sheets_duplicate_sheet - First observed
sheets_format_cells - First observed
sheets_get_metadata - First observed
sheets_get_values - First observed
sheets_insert_sheet - First observed
sheets_merge_cells - First observed
sheets_unmerge_cells - First observed
sheets_update_borders - First observed
sheets_update_sheet_properties - First observed
sheets_update_values
TDQS
B3.4/5.0
Disambiguation4/5
The tool set has many getters (values, formatting, structure, snapshot, etc.) that could cause confusion, but each has a clearly distinct purpose with detailed descriptions (e.g., full snapshot vs. specific attribute getters). A few tools like get_sheet_formatting and get_formatting_compact overlap in scope, but their output formats differ enough to disambiguate.
Naming Consistency5/5
All tools follow a consistent 'sheets_verb_noun' pattern with snake_case. Compound verbs like 'batch_get_values' and 'get_full_sheet_snapshot' are used uniformly. There are no camelCase or mixed conventions, making the naming highly predictable.
Tool Count2/5
With 44 tools, this server far exceeds the typical well-scoped range (3-15) and the heavy threshold (25+). While the breadth covers many Google Sheets features, the granularity (e.g., separate getters for dimensions, borders, merges) makes the surface unwieldy and likely overwhelming for agents.
Completeness4/5
The server covers a wide range of operations: CRUD for values, sheets, tables, charts, formatting, merges, conditional formatting, and more. However, it lacks write operations for data validation and filters (only read), and does not include chart reading or some advanced features. These are minor gaps given the extensive coverage.
Maintenance
ActivityMaintained
ResponsivenessResponsive
Related MCP Connectors
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
An agent-first office suite Claude & ChatGPT read and write over one MCP URL.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Related MCP Servers
- FlicenseBqualityDmaintenanceAn MCP server that enables Claude to interact with Google Sheets via the SheetsDB API, supporting CRUD operations and smart data addition.6-
- AlicenseNot gradedqualityBmaintenanceA local MCP server that lets Claude read and write Google Sheets through the Google Sheets API v4, using OAuth2 authentication with your own Google account.221MIT
- AlicenseNot gradedqualityBmaintenanceAn MCP server that lets Claude read, edit, and format Google Sheets in place, including cell updates, formula filling, row/column operations, and find & replace.178MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/freema/mcp-gsheets'
If you have feedback or need assistance with the MCP directory API, please join our Discord server