Connect your AI to any database — PostgreSQL, MySQL, or SQL Server — in seconds.
Scored across 26 tools
Several tools occupy adjacent analytics/performance niches — analyze_table/data_profile/detect_anomalies/pii_scan and explain_query/optimize_query — and while descriptions try to differentiate them, an agent can easily pick the wrong one. Core resource actions like connections and saved queries are otherwise distinct.
The dominant pattern is snake_case verb_noun (add_connection, describe_schema, list_connections, test_connection), with only a few readable exceptions like data_profile, impact_analysis, query_history, and the single-word quota. Pluralization fluctuates and some query_* entries read as nouns rather than verbs, but the overall pattern is still predictable.
At 26 tools, this exceeds the 25+ threshold and feels overloaded for a single MCP surface. Several adjacent functions could be consolidated, and the high count makes discovery and selection slower than necessary.
The surface covers the core domain well: connection lifecycle, read-only SQL execution, schema introspection, profiling/PII detection, performance analysis, migration generation, guardrails, and query history are all represented. Minor gaps exist — no update for saved queries or connections, no ability to execute generated migrations — but agents can work around them.
Get a secure one-time link to register a new database connection with ThinAir Data (postgres, mysql, or mssql). This tool does NOT take a connection string as input — you'll open the returned link and paste the connection string into a secure web form; it is never sent through chat. The response includes connection_string_format and auth_note for the chosen dialect — surface both to the user verbatim. IMPORTANT for mssql: Azure SQL uses Microsoft Entra, so the connection string is HOST/DATABASE only (no credentials) and the tenant/client/secret go in the form's separate fields — never construct or suggest an mssql://CLIENT_ID:CLIENT_SECRET@host string (client secrets break URL parsing).
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | A short name for this connection, e.g. 'prod-postgres' or 'analytics-mysql'. | |
| dialect | Yes | Database engine for the new connection. |
| Name | Required | Description |
|---|---|---|
| cap | No | |
| name | No | |
| plan | No | |
| status | Yes | |
| dialect | No | |
| auth_note | No | |
| expires_in_s | No | |
| add_database_url | No | |
| connection_string_format | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With annotations only indicating non-read-only and non-destructive, the description carries the full burden of behavioral disclosure and does so comprehensively. It explains that the tool returns a one-time link, explicitly states the connection string is never sent through chat, and outlines the mssql-specific requirement that URLs must not include embedded credentials. This goes well beyond the annotations and provides essential operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately long but every sentence carries important information. It begins with the core action, then explains the non-obvious workflow (link, form, not via chat), and culminates in a high-risk mssql caveat. While slightly verbose, it is well-structured and front-loads the primary purpose, with no redundant phrases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (three dialects, a non-standard workflow, and a high-risk mssql edge case), the description covers all necessary aspects: what it returns, how to use it, what to do with the response fields, and a critical pitfall. Since an output schema exists, the description does not need to enumerate return values, but it still highlights key response elements, making it fully adequate for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents both `name` and `dialect` with descriptions, achieving 100% schema coverage. The description adds value by tying the dialect to specific behavioral implications (e.g., mssql's Azure SQL handling) and indirectly explaining how the name parameter is used (as a short connection identifier). This exceeds the baseline for fully covered schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to obtain a secure one-time link for registering a new database connection, and explicitly lists supported dialects (postgres, mysql, mssql). It also distinguishes itself from typical connection tools by emphasizing that it does NOT take a connection string as input, clarifying its unique role among siblings like test_connection or list_connections.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides concrete usage guidance: open the returned link, paste the connection string into a secure web form, and surface `connection_string_format` and `auth_note` to the user. It also warns against constructing a particular mssql URL format. However, it does not explicitly contrast with alternative tools or state conditions for when to prefer this tool over others, so the intended use case is clear but not fully differentiated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
QUICK statistical snapshot for ONE table — row count, null rates, cardinality, numeric min/max/avg, date ranges. Optionally drill into a specific column. Use this for a fast at-a-glance read. Use data_profile instead when the user wants a FULL quality report including PII detection and a health score.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table name to analyze | |
| column | No | Specific column to deep-analyze | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds context on the tool's output scope (one table, stats) and its 'quick' nature, which is helpful. It does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with four short sentences that front-load the key purpose and output, then add usage guidance and the alternative tool. No filler or redundant wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema and annotations covering read-only/idempotent behavior, the description is complete. It clearly states what the tool does, what it returns (statistics), when to use it vs alternatives, and that the column parameter is optional. Nothing essential is missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with detailed descriptions for all three parameters, including the connection parameter's resolution guidance. The tool description only adds 'Optionally drill into a specific column' which is already implied by the schema's column parameter. It adds no substantial meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('snapshot'), a precise resource ('ONE table'), and enumerates the exact statistical outputs (row count, null rates, cardinality, min/max/avg, date ranges). It also explicitly names the sibling tool `data_profile` as a different, heavier alternative, making the distinction clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use guidance ('fast at-a-glance read') and directly points to `data_profile` for a full quality report with PII detection and health score. It also notes the optional column drill-down, providing clear selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage HARD SQL guardrails for an enterprise connection: a TABLE ALLOWLIST (queries may reference only the listed tables — enforced at the AST level across subqueries/CTEs/JOINs) and a PII MASKING policy (mask flagged columns in query results). Both opt-out by default. action=view shows current policy + schema reference; set_tables replaces the allowlist (use [] to lock down everything); remove_allowlist disables it; set_pii_policy toggles masking + chooses which PII kinds to mask. Masking is a heuristic policy aid (not a compliance guarantee) and one-way per execution. [ENTERPRISE tier]
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | What to do | |
| tables | No | For set_tables: the allowlist. Bare ('users') or one-level schema-qualified ('public.users'). Empty array = lock down (no tables allowed). | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect. If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| pii_enabled | No | For set_pii_policy: enable or disable result masking. | |
| mask_patterns | No | For set_pii_policy: which PII kinds to mask (defaults to all when enabling without a list). |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Adds substantial behavioral context beyond annotations: opt-out by default, AST-level enforcement across subqueries/CTEs/JOINs, one-way masking, and heuristic (non-compliance) nature. Also notes that [] locks down everything. No contradiction with destructiveHint=true.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Dense but well-structured: overview of the two guardrails, then explicit action list with usage, then a critical caveat. Every sentence earns its place with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters and multiple actions, the description covers all actions, their effects, key caveats (opt-out, one-way, heuristic), and AST enforcement. Output schema handles return values, so that is not needed. Combined with rich schema and annotations, it is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with detailed parameter descriptions, so baseline is 3. The main description adds cross-references (which action uses which parameter) and the one-way masking caveat, providing additional semantic context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Manage') and resource ('HARD SQL guardrails for an enterprise connection'), then details the two policies (TABLE ALLOWLIST and PII MASKING) and lists concrete actions. It clearly differentiates from siblings like query_firewall or pii_scan by focusing on allowlist/PII policy configuration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for each action (view, set_tables, remove_allowlist, set_pii_policy) and explains when to use them. However, it does not explicitly mention alternatives or when NOT to use this tool versus siblings like pii_scan or query_firewall, so 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.
⚠️ SQL MUST BE VALID IN EVERY DIALECT YOU TARGET — stick to ANSI-ish SELECT syntax when mixing pg/mysql/mssql. SELECT TOP 10 (mssql) or LIMIT (others) will fail on the wrong side. Run the same query across 2-4 connections in parallel; returns per-connection rows + errors for diffing. Canonical use cases: regional compare (['mssql-reporting-us', 'mssql-reporting-eu']), cross-dialect sync check (['prod-postgres-fleet', 'prod-mysql-app']), 3-env drift, 4-region compare. Resolve every connection name via list_connections first; tool fails per-connection on unknown names. ARCHITECT-tier cap: 4 connections; https://www.thinair.co/ for unlimited. [ARCHITECT tier]
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | SQL query to run on each connection. Must be valid in every dialect targeted — prefer ANSI SELECT syntax when mixing dialects. | |
| connections | Yes | Array of 2-4 connection NAMES (not IDs) from list_connections output. Examples: ['mssql-reporting-us', 'mssql-reporting-eu'] for regional compare, ['prod-postgres-fleet', 'prod-mysql-app'] for cross-dialect sync check. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true. The description adds significant behavioral details beyond this: parallel execution, per-connection error reporting, per-connection failure on unknown names, and the ARCHITECT-tier connection cap. It also warns about dialect compatibility. This is rich behavioral context that a caller needs to anticipate results and errors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a critical warning, but it becomes somewhat verbose. It includes multiple ad-hoc use cases and a URL to a tier page, which could be trimmed. The structure is logical but the information density could be higher. Some redundancy exists between the schema and description (e.g., dialect warning appears in both). This is adequate but not optimal conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (cross-dialect, parallel execution, multiple connections), the description covers all necessary aspects: dialect validity, connection resolution, error per connection, tier cap, and use cases. An output schema exists, so return value details are not needed in the description. The description is sufficient for an agent to select and invoke the tool correctly, including understanding failure modes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and both parameters (sql and connections) already have descriptive text in the schema. The description enhances this by adding concrete syntax warnings (e.g., 'SELECT TOP 10' vs 'LIMIT'), examples of connection arrays, and the mandatory constraint of resolving names via list_connections. It goes beyond the schema but does not fully compensate for the lack of enums or additional constraints; still, the added dialect guidance is valuable.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Run the same query across 2-4 connections in parallel; returns per-connection rows + errors for diffing.' It specifies a concrete action (run query), resource (multiple connections), and outcome (rows and errors for comparison), which distinguishes it from single-connection tools like query_sql.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit use cases (regional compare, cross-dialect sync check, 3-env drift, 4-region compare) and a prerequisite ('Resolve every connection name via list_connections first'). It does not explicitly name alternative tools or state when not to use it, but the prerequisites and canonical examples give clear guidance. The absence of a direct 'when-not' keeps it from a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
FULL data quality + compliance report for a table: per-column stats PLUS a 0-100 health score, type-gated PII detection (email / phone / SSN / etc.), and insight warnings. Slower than analyze_table but returns everything needed to audit a table for ownership / compliance / onboarding. Use this when the user says 'profile' or 'quality report' or mentions PII/compliance. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table to profile | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description adds useful behavioral context: it is slower than 'analyze_table', returns a complete audit package, and includes PII detection and health scoring. This goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with 'FULL' and enumerating key outputs. It efficiently combines purpose, differentiation, and usage triggers with no filler. Slightly dense but well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers the tool's purpose, key outputs, usage conditions, and performance trade-off. The output schema exists to detail return values, so the description adequately orients an agent. It does not over-explain, but leaves no critical gaps for invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for both parameters, with the 'connection' parameter already having detailed resolution guidance. The description does not add parameter-specific meaning beyond what the schema provides, so it meets the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly defines the tool as a comprehensive data quality and compliance report, listing specific components (per-column stats, 0-100 health score, type-gated PII detection, insight warnings). It also differentiates from the sibling 'analyze_table' by noting it is slower but more thorough, so an agent can distinguish them at a glance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool: 'Use this when the user says \'profile\' or \'quality report\' or mentions PII/compliance.' It also contrasts with 'analyze_table' to guide selection. This provides direct, actionable usage criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Introspect the full database structure for a connection: every table, column, type, primary key, foreign key, and index — the map to build queries against an unfamiliar database. Use analyze_table or data_profile instead when you need column VALUES (stats, nulls, PII) rather than structure. Read-only against your database. Results are cached 1 hour per connection; pass refresh=true to force a live re-introspection and bypass that cache, e.g. right after altering the schema. Does not consume daily quota. Returns tables with their columns, types, keys, and indexes.
| Name | Required | Description | Default |
|---|---|---|---|
| refresh | No | Force live introspection, bypassing cache | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description adds important non-obvious behavior beyond annotations: 1-hour per-connection caching, the refresh=true escape hatch, and the fact that it does not consume daily quota. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately sized but every sentence provides distinct value: purpose, alternatives, read-only safety, caching behavior, quota note, and return contents. It is front-loaded with the core purpose. Slightly dense, but not wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool takes only optional parameters, has an output schema, and carries strong annotations. The description covers usage context, alternatives, safety, cache behavior, and output contents. Nothing an agent needs to decide whether to call it and how to do so correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema carries most parameter documentation. The description adds contextual meaning to refresh by explaining the 1-hour cache it bypasses, which goes beyond the schema's 'Force live introspection, bypassing cache'. The connection parameter is already richly documented in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Uses a specific verb ('Introspect') with a clear resource ('full database structure for a connection') and enumerates the returned content: tables, columns, types, keys, and indexes. It also differentiates itself from sibling tools analyze_table and data_profile, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool versus alternatives: 'Use analyze_table or data_profile instead when you need column VALUES...' It also gives concrete operational guidance about caching and refresh behavior, so an agent knows exactly when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scan a table for unusual patterns: volume drops/spikes, data gaps, value concentration, high null rates, stale data. Severity-ranked alerts. Tables > 100k rows use a sampled path (~5%) — when a finding has sampled:true, surface it to the user with a hedge like 'based on a ~5% sample' rather than presenting the number as exact. Dialect-aware: TABLESAMPLE SYSTEM on postgres, TABLESAMPLE PERCENT on mssql, WHERE RAND() on mysql.
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table to scan for anomalies | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| date_column | No | Date column for trend analysis (auto-detected if omitted) |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly and idempotent annotations, the description discloses critical runtime behavior: tables over 100k rows use a sampled path, findings carry a sampled:true flag, and results should be hedged as sample-based. It also reveals dialect-specific SQL implementation, which is valuable context the annotations cannot convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but efficient: it states the purpose, then the sampling caveat, then the dialect-aware behavior. Every sentence earns its place, and the most operationally important caveat is included without filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present and annotations covering safety, the description supplies the missing operational context needed to invoke the tool correctly: sampling threshold, hedging requirement, and dialect differences. Nothing essential for correct invocation appears to be missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents all three parameters with 100% coverage, so the description does not need to repeat them. The tool description adds no parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool scans a table for unusual patterns and enumerates the specific anomaly types (volume drops/spikes, data gaps, value concentration, high null rates, stale data). It is clear and specific, but it does not explicitly distinguish itself from sibling tools like analyze_table or data_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: use this tool when a table needs anomaly detection. However, it does not explicitly state when to prefer it over alternatives or when not to use it, leaving the agent to infer the selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze a SQL query's execution plan and return plain-English performance recommendations. What runs, per dialect: postgres — EXPLAIN (FORMAT JSON), an ESTIMATED plan; the query is NOT executed and there are no measured timings (ANALYZE would execute it). mysql 8.0.18+ — EXPLAIN ANALYZE, which DOES execute the query to obtain real timings. mysql <8.0.18 — EXPLAIN FORMAT=JSON (estimated). mssql — SET SHOWPLAN_XML ON (estimated, not executed). Costs and row counts on an estimated plan are the planner's guesses: report them as estimates, not as observed behaviour. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| sql | Yes | The SELECT query to analyze | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite readOnlyHint=true, the description transparently discloses that mysql 8.0.18+ executes the query via EXPLAIN ANALYZE, while other dialects do not. It also warns that costs/row counts are estimates on estimated plans, adding critical behavioral nuance beyond annotations. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-organized by dialect, front-loading the primary purpose. Each sentence provides distinct value—no filler. It is longer than average but justified by the dialect matrix and estimate caveat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (dialect variations, execution vs estimated) and that an output schema exists, the description covers all necessary operational aspects: what runs per dialect, whether the query executes, and how to interpret results. No critical behavioral gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both 'sql' and 'connection' parameters already described in the input schema. The tool description adds no new parameter-level detail, so baseline 3 applies. It does not clarify parameter semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear verb+resource: 'Analyze a SQL query's execution plan and return plain-English performance recommendations.' This is specific and distinguishes it from siblings like query_sql or optimize_query by focusing on execution plan analysis with human-readable output.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains dialect-specific execution behavior but does not provide explicit when-to-use vs alternatives guidance. It implies usage for performance analysis but never names a sibling like optimize_query or find_n_plus_one, nor states when not to use it. The context of siblings is left to the agent to infer.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Detect N+1 query patterns from your own query_history, not a live trace: fingerprints the last 100 recorded queries tenant-wide (numeric/string literals normalized to ?; connection is accepted but does not scope which history is scanned) and flags any fingerprint repeated min_executions+ times (default 5), skipping trivial no-FROM-clause probes like SELECT 1. Always read-only. Needs populated history first (run queries via query_sql or saved_queries); empty history returns no patterns. Counts against daily quota. Returns fingerprint, execution count, total/avg time, an example query, and severity-ranked insights (critical above 20 repeats). [ARCHITECT tier]
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| min_executions | No | Minimum executions to flag (default 5) |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Even with readOnlyHint already in annotations, the description goes well beyond it: tenant-wide last-100 scan scope, literal normalization, connection not scoping history, skipping SELECT 1 probes, output fields, severity threshold, and daily quota impact. This is rich, non-obvious behavioral context that structured fields cannot convey.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose and packs dense behavioral detail with minimal fluff. It loses top marks only because 'Always read-only' redundantly restates the readOnlyHint annotation, which is a small but present repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with two optional parameters, an output schema, and annotations, the description covers prerequisites, side effects, return content, and edge cases such as empty history and connection non-scoping. No obvious gap remains for an agent to invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 adds genuine semantic value by clarifying that connection is accepted but does not scope which history is scanned, and that min_executions is the repeat threshold with a default of 5, which the schema does not fully express.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens by naming the exact operation and resource: detect N+1 patterns from query_history, not a live trace. The fingerprinting and repeat-count detail make it clearly distinct from siblings like detect_anomalies, explain_query, or optimize_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states the key precondition that history must be populated and names query_sql and saved_queries as ways to populate it. It also notes empty history returns no patterns and that the call counts against the daily quota. It does not explicitly compare with alternative sibling tools, but the not-a-live-trace exclusion narrows applicability.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate dialect-correct ALTER TABLE migration SQL + rollback from a plain-English intent. Output uses the connection's exact dialect (ALTER TABLE for all three, plus pg-specific USING casts / mssql-specific sp_rename / mysql-specific MODIFY COLUMN). Never executes. Check response dialect field before manually editing — don't hand-translate across dialects. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| intent | Yes | Plain English: 'add soft delete to drivers', 'add index on trips.driver_id' | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description explicitly states 'Never executes' and explains that output is dialect-specific and includes rollback. It adds practical behavioral guidance: check the dialect field rather than manually translating between dialects. This substantially enriches the annotation-only signal and is consistent with 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two dense sentences plus a tier tag, with the core action front-loaded. Dialect behavior, safety, and post-output guidance each earn their place. There is no filler or repetition of schema content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers scope, dialect behavior, non-execution, rollback, and the dialect-checking workflow. With annotations and an output schema present, an agent has enough to call this tool correctly. The only minor gap is that it does not state explicit exclusions such as which migration operations are unsupported, though the ALTER TABLE scope is already clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents both parameters well. The tool description adds useful context about plain-English intent and connection-determined dialect, but it does not go into parameter-specific semantics beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Generate dialect-correct ALTER TABLE migration SQL + rollback from a plain-English intent.' It names concrete dialect behaviors and explicitly states the tool never executes, which separates it from query/execution siblings like query_sql. The purpose is unambiguous and scopes the tool to migration generation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use plain-English intent to generate dialect-correct migration SQL with rollback, and never execute. It also instructs the agent to check the response 'dialect' field before manual editing and not hand-translate across dialects. It does not explicitly name alternative tools or when-not-to-use conditions, so it stops 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.
Generate realistic, schema-aware INSERT statements for development and testing. Respects types, constraints, and FK relationships. Never executes. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table to generate seed data for | |
| format | No | Output format (default sql) | |
| row_count | No | Number of rows (default 100, max 1000) | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is established. The description adds meaningful behavior beyond these hints by specifying that output respects database constraints and foreign keys, and by explicitly stating 'Never executes' as a hard behavioral guarantee. No contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences plus a tier tag, with no wasted words. It front-loads the core purpose, then adds behavioral constraints and safety information in a compact, scannable format.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a generation tool with a full input schema and an output schema present, the description covers the essential purpose, schema-awareness behavior, and execution safety. It does not mention the connection parameter or output format, but those are already thoroughly documented in the schema, so nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline of 3 applies. The description itself adds no per-parameter detail; all parameter meaning is fully documented in the input schema, including extensive guidance for the connection parameter. The description does not need to compensate for any schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb ('Generate'), a concrete deliverable ('realistic, schema-aware INSERT statements'), and an explicit use case ('for development and testing'). It further distinguishes the tool by mentioning that it respects types, constraints, and FK relationships, which clearly separates it from siblings like generate_migration or query_sql.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for development and testing' provides a clear situational trigger, and 'Never executes' implies it should not be chosen when execution is required. However, the description never names an alternative tool or states explicit when-not-to-use conditions, so the agent must infer routing from the sibling list and general context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze the blast radius of a proposed schema change: FK dependencies, affected views, row count, risk score. [ARCHITECT tier]
| Name | Required | Description | Default |
|---|---|---|---|
| intent | Yes | Describe the change: 'rename vehicle_id to vehicle_uuid on trips', 'drop column X' | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the description doesn't need to repeat safety. It adds value by specifying what the analysis covers (FK dependencies, views, row count, risk score), which enriches the behavioral picture. The '[ARCHITECT tier]' tag hints at access level, adding context 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense sentence that front-loads the purpose and key outputs, then adds the tier tag. There is zero redundancy, and every element earns its place. It is appropriately sized for a read-only analysis tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only analysis tool with a detailed schema and an output schema, the description is nearly complete. It lacks explicit mention of prerequisites or limitations (e.g., need for an active connection), but the connection parameter description covers resolution. The main gap is not naming sibling alternatives, but that's not essential for calling the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with detailed descriptions for both 'intent' and 'connection', including examples and resolution instructions. The tool description itself adds no parameter-specific details beyond what the schema already offers. Since the schema does the heavy lifting, a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes blast radius of a schema change, listing specific outputs (FK dependencies, affected views, row count, risk score). This distinguishes it from siblings like analyze_table or describe_schema, which focus on different aspects. The verb 'analyze' and resource 'schema change' make the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for assessing the impact of a proposed schema change, which is a clear context. However, it doesn't explicitly mention when not to use it or name alternatives, though the connection parameter description does guide on resolving connection names. The lack of explicit exclusions or sibling references leaves a small gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Issue a fresh ta_data_* API key for ThinAir DATA (databases/SQL) for your current tenant, and rotate: any previous key keeps working for one hour, then stops — the response reports how many and exactly when (previous_keys_retiring, previous_keys_retire_at). Use it to rotate, or when an integration needs a key and can't reach the console. The new key is tied to your existing plan tier. Rate-limited to 5 issuances per tenant per day. NOTE: this key works ONLY against ThinAir Data — it does NOT authenticate against ThinAir Geo, which issues its own ta_geo_* key from its own identically-named tool.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| note | No | |
| plan | No | |
| user | No | |
| error | No | |
| usage | No | |
| key_id | No | Non-secret fingerprint of the issued key. Safe to log and surface in UI. |
| status | Yes | |
| api_key | No | One-time API key secret. Returned only on successful creation, in both structuredContent.api_key and content[0].text — save it immediately. The server stores only sha-256 of the secret; once this response is lost, the key is unrecoverable and must be rotated. Matches AWS IAM / Stripe / GitHub PAT one-time-reveal semantics. |
| tenantId | No | |
| retry_after_s | No | |
| previous_keys_retiring | No | How many previously-live keys this mint scheduled to retire. issue_api_key rotates: after the grace window the returned key is the only live key on the tenant. 0 means there was nothing else. |
| previous_keys_retire_at | No | ISO 8601 instant when the previous keys stop working (one hour after this mint). Present only when previous_keys_retiring > 0. Update anything still using them before this time. |
| credential_returned_once | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations, the description discloses rotation semantics (previous key works for one hour), response fields (previous_keys_retiring, previous_keys_retire_at), plan-tier binding, a daily rate limit, and auth scope. No contradictions with annotations; the behavioral detail is rich and actionable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Every sentence adds operational value: action, rotation, response, use case, rate limit, and scope exclusion. The description front-loads the core action and then layers necessary constraints without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no parameters and an output schema present, the description covers all behavioral context an agent needs: rotation timing, rate limit, scope, and use cases. There are no significant gaps for selecting or invoking this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters and schema coverage is 100%, so the description is not required to explain inputs. It still adds relevant contextual scoping ('current tenant') and key-format behavior, earning the baseline for a no-param tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific action ('issue'), the resource (ta_data_* API key), target (ThinAir DATA/SQL, current tenant), and distinguishes it from a Geo sibling key. Clear enough for an agent to identify this as the key-issuance tool among the sibling data tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use it to rotate, or when an integration needs a key and can't reach the console.' Also provides a when-not and an alternative: the key does not authenticate against ThinAir Geo, which has its own tool issuing ta_geo_*.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List every database connection registered for your tenant: name, id, dbType (postgres / mysql / mssql), createdAt. Flags duplicate names — only the first-added connection of a duplicate name is reachable by name. Returns nothing sensitive (no DSN, no credentials).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and idempotentHint annotations, the description reveals duplicate-name behavior (only the first-added connection of a duplicate name is reachable by name) and explicitly states that no sensitive data is returned (no DSN, no credentials). This adds valuable operational context 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero wasted words. The core purpose and returned fields are front-loaded in the first sentence, with important caveats (duplicate handling and security) in the second. Structure is optimal.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only list tool, the description covers what it returns, duplicate handling, and the security posture. An output schema exists, but the description already summarizes the returned fields, making it complete for an agent to invoke correctly without further inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters (schema is empty), so the description has nothing to add. The baseline of 4 is appropriate because there is no ambiguity to resolve and the schema coverage is trivially 100%.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('database connection registered for your tenant'), and enumerates the returned fields (name, id, dbType, createdAt). It clearly distinguishes itself from siblings like add_connection or remove_connection by focusing on read-only enumeration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly states what the tool does, implying it should be used when an agent needs to see registered connections. It does not explicitly name alternatives or exclusions, but the context is unambiguous enough for an agent to select it over test_connection or other siblings. A slight gap is the absence of an explicit 'use when' or 'when not to use' statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Analyze a SQL query's plan and return ranked optimization recommendations with explanations. Returns a verdict (efficient / needs_attention) plus findings: full/sequential scans, nested-loop joins, and — on mysql — temporary tables and filesorts. It does NOT return a rewritten query; original_query comes back unchanged and any rewrite is yours to author from the recommendations. The plan is ESTIMATED on all three dialects (pg EXPLAIN (ANALYZE false, FORMAT JSON), mysql EXPLAIN, mssql SHOWPLAN_XML) — the query is never executed, so run-time-only conditions such as a sort spilling to disk cannot be detected and are not reported. Ready-to-run index DDL is available only on mssql, where SHOWPLAN carries the optimizer's own missing-index statements; on postgres/mysql the recommendation names the WHERE/JOIN columns to index instead. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | SQL query to optimize | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond the readOnlyHint/idempotentHint annotations by explaining that the query is never executed, the plan is estimated on all dialects, and runtime-only conditions cannot be detected. It also discloses dialect-specific behavior such as index DDL being available only on mssql. This is rich, honest behavioral context that an agent can act on.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence earns its place: purpose, output shape, non-rewrite behavior, safety model, dialect differences, and limitations are all covered. It is front-loaded with the core purpose and then adds necessary caveats without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with two parameters, an output schema, and annotations, the description is remarkably complete. It explains what the tool returns, what it never does, how it behaves across dialects, and what an agent should expect. Nothing critical is missing for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly, including the connection resolution guidance. The description itself does not add much parameter-specific meaning, but it also does not need to because the schema carries the burden. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: it analyzes a SQL query's plan and returns ranked optimization recommendations. It distinguishes itself from a plain plan explainer by mentioning the verdict and findings, and explicitly clarifies that it does NOT return a rewritten query. This gives an agent a clear, distinct purpose even among plan-related siblings like explain_query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: when an agent needs optimization recommendations for a SQL query. It also gives important exclusions, such as not returning a rewritten query and not detecting runtime-only conditions. It does not explicitly name sibling alternatives, but the purpose and limitations are clear 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.
Sweep string columns across tables for common PII patterns (email, SSN, credit card, phone, JWT, bearer tokens). Heuristic-only — not a compliance guarantee. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| max_tables | No | Max tables to sample (default 25, cap 50) | |
| sample_rows | No | Rows sampled per table (default 20, cap 100; values < 5 are floored to 5) |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover readOnlyHint, openWorldHint, and idempotentHint, so the description correctly focuses elsewhere. It adds important behavioral context by disclosing that results are heuristic-only and not a compliance guarantee, which is not evident from annotations or schema. This is valuable beyond structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-ordered: the first sentence communicates the core action and scope, while the second adds the key caveat. The '[BUILD tier]' tag is a small, useful context marker and nothing in the description is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a full output schema, fully documented parameters, and read-only/idempotent annotations, the description does not need to explain return values or side effects. It covers purpose, scope, and behavioral limits; the only contextual gap is explicit guidance on when to choose this tool over closely related siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, including defaults, caps, flooring behavior, and connection-resolution guidance. The description adds no parameter-level detail, so the baseline of 3 is appropriate; the schema already carries the full explanatory burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('sweep'), a clear resource ('string columns across tables'), and enumerates concrete PII patterns (email, SSN, credit card, phone, JWT, bearer tokens). The PII focus clearly separates it from sibling tools like data_profile, analyze_table, or detect_anomalies even without naming them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for heuristic PII discovery and explicitly warns that it is 'not a compliance guarantee,' giving a when-not. However, it does not explicitly say when to prefer this tool over data_profile, analyze_table, or describe_schema, nor does it name an alternative tool for compliance-grade scanning.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manage and test per-connection SQL firewall rules that block, warn, or log matching queries — distinct from pii_scan, which scans stored data (not SQL text) for PII. action=add_rule creates a rule (rule_name + RE2 pattern; optional block_action: block/warn/log, default block — only "block" is enforced, "warn"/"log" are advisory-only). action=remove_rule deletes by name or id. action=list_rules is read-only. action=test_query checks a sql string against the built-in guard plus your rules and returns a verdict without running it. add_rule/remove_rule write; changes take effect within 60s. All actions count against quota. Limits: 50 rules/connection, 512-char patterns. [ARCHITECT tier]
| Name | Required | Description | Default |
|---|---|---|---|
| sql | No | SQL to test against rules | |
| action | Yes | What to do | |
| message | No | Message shown when rule triggers | |
| pattern | No | Regex pattern to match | |
| rule_name | No | Rule name | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| block_action | No | Action when matched (default block) |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already signal destructive/read flags, but the description goes well beyond: it names which actions write vs read, discloses the 60-second propagation delay, quota impact for all actions, rule/pattern limits, and the important caveat that warn/log are advisory-only while only block is enforced. No contradictions 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence contributes: main purpose, sibling distinction, per-action behavior, enforcement caveat, propagation latency, quota, and hard limits. It is front-loaded with the core purpose and avoids filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a multi-action tool with 7 parameters and an output schema, the description covers action semantics, side effects, timing, quotas, limits, and the no-execution safety property of test_query. The connection parameter's resolution rules are already documented in the schema, so nothing needed for safe invocation is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so a baseline of 3 applies. The description adds meaningful usage semantics on top: add_rule requires rule_name + RE2 pattern, default block_action is block, warn/log are advisory, remove_rule accepts name or id, and test_query uses a sql string. It does not repeat plain schema field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb/resource ('Manage and test per-connection SQL firewall rules') and explains the block/warn/log behavior. It explicitly differentiates itself from the pii_scan sibling by what it operates on (SQL text vs stored data), so an agent can distinguish it immediately.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives action-by-action guidance (add_rule, remove_rule, list_rules, test_query) and explicitly says test_query does not run the SQL, which separates it from query execution tools. It names only pii_scan as a 'not this' alternative, so guidance is clear but not exhaustive across all siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read-only audit log of your own recent query executions on this tenant — SQL text (truncated to 200 chars), execution time, row count, source tool, and error status. History is tenant-wide across every connection: connection only selects which name/dialect is echoed in meta, not which entries return. Looks backward only: use suggest_queries for NEW query ideas, or saved_queries to store and re-run a query by name. Backed by a 100-entry ring buffer per tenant, 7-day retention; limit (default 20, max 100) trims how many return, not how far back history goes. Counts against daily quota. Returns a table of {sql, execution_ms, rows, tool, error, time}. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of recent queries (default 20, max 100) | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Despite readOnlyHint annotation, the description adds significant behavioral detail: 200-char truncation, 100-entry ring buffer, 7-day retention, daily quota impact, and the distinction between limit trimming count vs lookback. These details are not present in annotations or schema, and there is no contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is dense but every sentence adds value – it covers purpose, scope, edge-case parameter behavior, exclusions, limits, and return format. It is front-loaded with the core purpose and field list, then elaborates on nuances. No filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity with two optional parameters and a defined return shape, the description covers all necessary aspects: return columns are listed, limits are explained, quota impact is disclosed, and connection resolution guidance is provided. It is self-sufficient even without the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters fully (100% coverage) with detailed descriptions, but the description adds behavior beyond schema: connection only selects the echoed name/dialect, not which entries return; limit trims result count, not lookback window. This adds meaning beyond the JSON schema's definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific purpose: read-only audit log of recent query executions, listing SQL text, execution time, row count, source tool, and error status. It explicitly contrasts with siblings by directing new queries to suggest_queries and saved_queries for storage/re-run. The 'tenant-wide' scope is clarified, making it unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit exclusions: 'use suggest_queries for NEW query ideas, or saved_queries to store and re-run a query by name'. Clarifies the connection parameter doesn't filter results, only affects echoed metadata. Also explains limit behavior and default, eliminating guesswork.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Execute a read-only SQL query against the target connection. ONLY SELECT / WITH / EXPLAIN permitted. Write dialect-appropriate SQL for the connection's engine — use PostgreSQL syntax for postgres connections (SELECT NOW(), LIMIT, ILIKE), T-SQL for mssql (SELECT GETDATE(), TOP N, LIKE), MySQL for mysql (SELECT NOW(), LIMIT). Response meta includes connection + dialect so you know which syntax worked; reuse that dialect in follow-up calls. Default LIMIT 100 unless the user asks for all rows.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max rows to return (default 100, max 1000) | |
| query | Yes | SQL SELECT query to execute | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint, openWorldHint, and idempotentHint. The description reinforces the read-only nature ('ONLY SELECT / WITH / EXPLAIN permitted') and adds critical behavioral details: the response meta includes connection + dialect, which the agent can use to adapt subsequent calls. It also discloses the default limit and the cap of 1000. This goes well beyond the annotations, providing concrete runtime behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph that front-loads the core purpose ('Execute a read-only SQL query') and immediately states the constraint (ONLY SELECT/WITH/EXPLAIN). Each subsequent sentence adds a distinct, essential piece of guidance (dialect, response meta, limit, connection selection). There is no filler or redundancy; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a SQL execution tool with three parameters, 100% schema coverage, and an output schema, the description covers all the essentials: the allowed operations, dialect handling, default and maximum limits, connection resolution, and the feedback mechanism (response meta). The agent has everything needed to select the right connection, write appropriate SQL, and interpret the result. No critical guidance is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents all three parameters (query, limit, connection) with descriptions, but the tool description adds substantial practical guidance. For 'connection', it explains how to discover valid values via list_connections and how to match them semantically to user intent. For 'limit', it clarifies the default value. This goes beyond the schema's static field descriptions, significantly improving the agent's ability to invoke the tool correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Execute a read-only SQL query against the target connection.' It specifies the allowed statement types (SELECT/WITH/EXPLAIN) and differentiates itself from siblings like cross_db_query by focusing on a single target connection. This is a specific, unambiguous definition that leaves no doubt about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit, actionable usage guidance: it instructs the agent to write dialect-appropriate SQL (with examples for PostgreSQL, T-SQL, MySQL), sets a default LIMIT of 100, and tells the agent to reuse the dialect from the response meta in follow-up calls. It also gives detailed instructions for selecting the 'connection' parameter by resolving it via list_connections. These are clear when-to-use and how-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check current API usage, daily limit, plan name, and upgrade options.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| plan | Yes | |
| used | Yes | |
| limit | Yes | |
| reset_at | No | |
| upgrade_url | No | |
| schema_version | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description's 'Check' is consistent. The description goes beyond the schema by specifying the returned information: API usage, daily limit, plan name, and upgrade options. It does not mention whether the check itself affects quota or requires authentication, but the read-only nature and output schema mitigate this.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence: 'Check current API usage, daily limit, plan name, and upgrade options.' Every word adds value, 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.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only tool with an output schema, the description fully covers the purpose and expected results. It clearly enumerates the returned quota details, making the tool self-explanatory within its context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema coverage is 100% (vacuously). Per guidelines, a zero-parameter tool gets a baseline of 4. The description correctly adds no parameter information because there is nothing to add.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Check' and identifies exact resources: API usage, daily limit, plan name, and upgrade options. This clearly distinguishes the tool from the data-analysis and connection-management siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for monitoring current quota status. Although it does not explicitly mention alternatives, no sibling tool appears to cover quota, so the usage context is clear. It lacks an explicit 'when not to use' statement, but that is not critical for a zero-parameter status tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Remove a stored database connection from ThinAir Data by name. This deletes ONLY ThinAir's saved connection record (name, encrypted DSN) — your actual database is never touched, nothing is dropped or altered on it. Call list_connections first if you're unsure of the exact name.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Exact name of the connection to remove, as shown by list_connections. |
| Name | Required | Description |
|---|---|---|
| id | No | |
| name | Yes | |
| status | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint=true), the description explicitly scopes the destructive behavior: 'This deletes ONLY ThinAir's saved connection record (name, encrypted DSN) — your actual database is never touched, nothing is dropped or altered on it.' This tells the agent exactly what is affected and reassures that external systems are safe, which is highly valuable for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two compact sentences plus a practical usage tip, with the core action front-loaded and every sentence contributing information. It explains scope, non-destructiveness, and how to get the correct input without any fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a simple one-parameter tool with full schema coverage, annotations (including idempotentHint and destructiveHint), and a provided output schema, the description covers all an agent needs to call it correctly: what it does, what it does not do, and how to determine the correct input. No critical gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already defines the 'name' parameter with full coverage (100%) and a description: 'Exact name of the connection to remove, as shown by list_connections.' The tool description repeats the need for the exact name but adds no new semantic meaning beyond the schema, so it correctly sits at the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with 'Remove a stored database connection from ThinAir Data by name,' which is a specific verb-resource pair that clearly states the tool's function. It distinguishes from siblings like add_connection, list_connections, and even instructs to use list_connections for uncertain names, so there is no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a concrete usage instruction: 'Call list_connections first if you're unsure of the exact name,' which tells the agent when to consult a sibling tool. It does not explicitly mention when not to use this tool, but since removing a connection is a distinct action with no close alternative, this is a clear and practical guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Personal, named library of reusable SELECT queries — save once, run by name later, instead of re-pasting SQL or scanning query_history's backward-looking log. action=save stores sql under name (fails with name_exists if taken — delete first to replace). action=run executes the stored SQL through the same read-only guard and firewall as query_sql and returns up to 100 rows. action=list returns saved queries (up to 100), optionally filtered by tag. action=delete removes one by name or id. save/run/delete write to tenant storage; list is read-only. All four actions count against daily quota. Returns the saved record, a result table (run), the query list, or a delete confirmation. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| id | No | Query ID (alternative to name for run/delete) | |
| sql | No | SQL to store (required for action=save) | |
| tag | No | Filter by tag (action=list) | |
| name | No | Query name (save/run/delete) | |
| tags | No | Tags (action=save) | |
| action | Yes | save | run | list | delete | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. | |
| description | No | Freeform description (action=save) |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare destructiveHint=true and readOnlyHint=false. The description adds valuable context: save/run/delete write to tenant storage, list is read-only, all actions count against daily quota, save fails with name_exists if taken, and run uses the same read-only guard and firewall as query_sql with a 100-row limit. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a dense single paragraph but well-organized: it opens with the purpose, then enumerates actions and their semantics, then notes on storage and returns. It covers a lot in about five sentences without redundancy, though a more structured layout could improve scanability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is thorough for a multi-action tool: it explains error behavior (name_exists), quota impact, read/write semantics, return types for each action, and references to the query_sql guard. With an output schema present, it still summarizes returns clearly, leaving no critical gap for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents each parameter. The description reinforces action-specific parameter usage (e.g., action=save stores sql under name) and the relationship between name and id for delete/run, but it doesn't add significantly beyond the schema, meeting the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb+resource: a personal library of reusable SELECT queries, and distinguishes itself from siblings by contrasting with query_history's backward-looking log and query_sql's direct execution. It clearly conveys the four actions (save/run/list/delete) and the core value proposition of saving once and running by name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says 'instead of re-pasting SQL or scanning query_history's backward-looking log', naming two alternatives and implying when to use this tool. It also describes the intended pattern (save once, run by name) but does not fully enumerate exclusion conditions or other alternatives like suggest_queries, so a 4 is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List active sessions + blocking locks. Uses the dialect's own system view — pg_stat_activity on postgres, information_schema.processlist on mysql, sys.dm_exec_requests joined with sys.dm_tran_locks on mssql. No dialect arg needed — inferred from the connection. Required privileges (per dialect): postgres — pg_read_all_stats role membership (or be the role that owns the queries; otherwise you only see your own session); mysql — PROCESS privilege; mssql — VIEW SERVER STATE. If the role lacks the privilege the tool returns a clean Query blocked by security policy error rather than partial data — grant the role above and retry. RDS/Aurora/Azure managed PostgreSQL: pg_read_all_stats is grantable but not on by default. [BUILD tier]
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond the readOnlyHint annotation by detailing exactly which system views are used, the required privileges per database, and the clean security-policy error returned when privileges are missing rather than partial data. It also notes a managed-PostgreSQL caveat, which is valuable behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long but every substantive detail earns its place: purpose, dialect-specific views, privileges, error behavior, and a managed-platform caveat. It is front-loaded with the core function and uses structured lists. Minor noise like '[BUILD tier]' and the exact error string could be trimmed, but overall it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the cross-dialect complexity paid, the description covers everything an agent needs to invoke the tool correctly: what it lists, how dialect is determined, required privileges, failure behavior, and a deployment-specific caveat. The output schema covers return-value expectations, so no additional return description is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter is already thoroughly documented in the schema, including how to resolve the connection name. The tool description adds meaning by clarifying that no dialect argument is needed and that the dialect is inferred from the connection, which directly helps an agent correctly invoke the tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'List active sessions + blocking locks.' It further disambiguates from generic SQL/query tools by naming the exact dialect-specific system views it consults, so an agent can clearly tell what this tool is for.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear operational guidance: no dialect argument is needed, the dialect is inferred from the connection, and required privileges per dialect are spelled out with a retry instruction on failure. It does not explicitly name alternative sibling tools or state when not to use this tool, but the context is strong 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.
Generate schema-aware query suggestions with ready-to-run SQL. Great for exploring unfamiliar databases or finding useful queries.
| Name | Required | Description | Default |
|---|---|---|---|
| context | No | Topic or goal to focus suggestions | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds value by noting the tool is 'schema-aware' and produces 'ready-to-run SQL', which tells the agent the output is actionable. The connection parameter guidance about resolving names from list_connections adds behavioral context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero waste. The first sentence states the core function and output format, and the second gives the primary use case. The parameter descriptions are detailed but focused, with actionable guidance for the agent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema, so return values don't need explanation. The description covers the tool's purpose, use case, and connection resolution strategy. The only minor gap is that it doesn't explicitly state what happens when no context is provided (though the parameter is optional), but this is a small omission given the overall completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters well. The description adds value by explaining the 'context' parameter's purpose ('Topic or goal to focus suggestions') and the connection parameter's resolution strategy (match semantically to user intent, use default if unspecified). This goes beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: generating schema-aware query suggestions with ready-to-run SQL. It also specifies the use case ('exploring unfamiliar databases or finding useful queries'), which distinguishes it from siblings like query_sql (executing queries) and explain_query (explaining existing queries).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool ('exploring unfamiliar databases or finding useful queries'), and the connection parameter description explicitly instructs the agent to call list_connections to resolve connection names. However, it doesn't explicitly state when NOT to use it or name alternative tools for comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Ping a connection (SELECT 1) and return server version + latency. Fast way to confirm credentials and network path without running describe_schema.
| Name | Required | Description | Default |
|---|---|---|---|
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds valuable context: the exact query (SELECT 1), return values (server version + latency), and speed. This goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One concise sentence, front-loaded with the core action and return values, followed by a clarifying use case. No redundant words or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Simple tool with a single optional parameter (fully documented in schema), an output schema, and annotations covering safety. The description covers purpose, usage, and key behavioral details, leaving nothing essential missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the schema itself provides a thorough explanation of the connection parameter, including resolution rules and default behavior. The tool description adds nothing beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('ping') with resource ('connection') and explicit output (server version + latency). Contrasts directly with sibling describe_schema, making the tool's unique role clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly frames the tool as a fast way to confirm credentials and network path, and explicitly names describe_schema as an alternative not to use. Gives clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Snapshot a table's row count and latest record, and compare against the snapshot taken by the PREVIOUS call. There is no scheduler and no background polling — nothing runs between calls, so the first call only establishes a baseline and you must call it again to see any change. [ARCHITECT tier]
| Name | Required | Description | Default |
|---|---|---|---|
| table | Yes | Table to monitor | |
| column | No | Date column to track latest | |
| condition | No | What to watch: 'new rows', 'row count drops' | |
| connection | No | Target connection name from this tenant's inventory. Call `list_connections` to see every name + dialect, then match semantically to the user's intent (e.g. 'analytics' → a connection named `*-analytics-*`; 'prod' → a connection with `prod-` prefix). If the user didn't specify, use the tenant's default (first added). Do not invent names — resolve from `list_connections` output. |
| Name | Required | Description |
|---|---|---|
| data | No | |
| meta | No | |
| display | No | |
| summary | No | |
| insights | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, so the description's note about no background polling and the need for a second call adds valuable behavioral context beyond the annotations. It clarifies that the tool is stateless between calls and relies on explicit re-invocation, which is not inferable from the 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the core function front-loaded and the crucial caveat about statelessness immediately following. Every word adds value, and there is no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is complete for an agent to call the tool correctly: it explains the purpose, the stateful behavior across calls, and the need for a second invocation. Since an output schema exists, the description doesn't need to detail return values. The [ARCHITECT tier] label also provides audience context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema thoroughly documents all four parameters, including the connection parameter with detailed resolution instructions. The description itself adds no additional parameter-specific semantics beyond what the schema already provides, so 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'snapshot and compare' with a clear resource (table row count and latest record), and distinguishes itself from siblings by focusing on change detection across calls rather than querying or analysis. It is clear and specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states there is no scheduler or background polling, so the first call only establishes a baseline and a second call is needed to see changes. This tells the agent when to use it (for change detection across calls) and when not (for real-time monitoring), though it doesn't name alternative tools. The [ARCHITECT tier] hint also signals intended usage level.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
analyze_table1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "avg": {
- "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
- },
- "cardinality_pct": {
- "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
- },
- "distinct_count": {
- "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
- },
- "earliest": {},
- "latest": {},
- "max": {},
- "min": {},
- "name": {
- "type": "string"
- },
- "null_pct": {
- "type": [
- "number",
- "string"
- ]
- },
- "top_values": {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- },
- "type": {
- "type": "string"
- }
- },
- "required": [
- "name"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": {},
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "avg": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "cardinality_pct": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "distinct_count": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "earliest": {},
+ "latest": {},
+ "max": {},
+ "min": {},
+ "name": {
+ "type": "string"
+ },
+ "null_pct": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "top_values": {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]configure_allowlist1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": {},
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]cross_db_query1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "connection": {
- "type": "string"
- },
- "error": {
- "type": [
- "string",
- "null"
- ]
- },
- "execution_ms": {
- "$ref": "#/properties/data/anyOf/0/items/properties/rows/anyOf/2"
- },
- "rows": {
- "anyOf": [
- {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- },
- {
- "type": "null"
- },
- {
- "type": [
- "number",
- "string"
- ]
- }
- ]
- },
- "sample": {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- }
- },
- "required": [
- "connection"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "connection": {
+ "type": "string"
+ },
+ "error": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "execution_ms": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/rows/anyOf/2"
+ },
+ "rows": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ },
+ {
+ "type": [
+ "number",
+ "string"
+ ]
+ }
+ ]
+ },
+ "sample": {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "connection"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]data_profile1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "cardinality": {
- "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
- },
- "distinct_count": {
- "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
- },
- "isPrimaryKey": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "null_pct": {
- "type": [
- "number",
- "string"
- ]
- },
- "nullable": {
- "type": "boolean"
- },
- "pii_risk": {
- "type": "boolean"
- },
- "pii_type": {
- "type": "string"
- },
- "type": {
- "type": "string"
- }
- },
- "required": [
- "name"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "cardinality": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "distinct_count": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "isPrimaryKey": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "null_pct": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "nullable": {
+ "type": "boolean"
+ },
+ "pii_risk": {
+ "type": "boolean"
+ },
+ "pii_type": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]describe_schema1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "columns": {
- "type": [
- "number",
- "string"
- ]
- },
- "details": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "defaultValue": {
- "type": [
- "string",
- "null"
- ]
- },
- "isPrimaryKey": {
- "type": "boolean"
- },
- "name": {
- "type": "string"
- },
- "nullable": {
- "type": "boolean"
- },
- "type": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "type"
- ],
- "type": "object"
- },
- "type": "array"
- },
- "name": {
- "type": "string"
- },
- "primaryKeys": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "name"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "columns": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "details": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "defaultValue": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "isPrimaryKey": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "nullable": {
+ "type": "boolean"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "type"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "name": {
+ "type": "string"
+ },
+ "primaryKeys": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]detect_anomalies1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "column": {
- "type": [
- "string",
- "null"
- ]
- },
- "message": {
- "type": "string"
- },
- "recommendation": {
- "type": "string"
- },
- "severity": {
- "anyOf": [
- {
- "enum": [
- "info",
- "low",
- "medium",
- "high",
- "warning",
- "critical"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
- ]
- },
- "type": {
- "type": "string"
- },
- "value": {}
- },
- "required": [
- "severity"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "low",
+ "medium",
+ "high",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "type": {
+ "type": "string"
+ },
+ "value": {}
+ },
+ "required": [
+ "severity"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]explain_query1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "original_sql": {
- "type": "string"
- },
- "plan": {}
- },
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "original_sql": {
+ "type": "string"
+ },
+ "plan": {}
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]find_n_plus_one1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "executions": {
- "type": [
- "number",
- "string"
- ]
- },
- "pattern": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "executions": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "pattern": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]generate_migration1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "down_sql": {
- "type": "string"
- },
- "intent": {
- "type": "string"
- },
- "up_sql": {
- "type": "string"
- },
- "warnings": {
- "items": {
- "type": "string"
- },
- "type": "array"
- }
- },
- "required": [
- "up_sql"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "down_sql": {
+ "type": "string"
+ },
+ "intent": {
+ "type": "string"
+ },
+ "up_sql": {
+ "type": "string"
+ },
+ "warnings": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "up_sql"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]generate_seed_data1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "anyOf": [
- {
- "type": "string"
- },
- {
- "items": {},
- "type": "array"
- }
- ]
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {},
+ "type": "array"
+ }
+ ]
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]impact_analysis1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "affected_views": {
- "items": {},
- "type": "array"
- },
- "analysis_scope": {
- "enum": [
- "table",
- "column"
- ],
- "type": "string"
- },
- "dependency_risk": {
- "type": "string"
- },
- "fk_dependencies": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "column": {
- "type": "string"
- },
- "direction": {
- "type": "string"
- },
- "references": {
- "type": "string"
- },
- "references_column": {
- "type": "string"
- },
- "table": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- "fk_dependencies_evaluated": {
- "type": "boolean"
- },
- "intent": {
- "type": "string"
- },
- "operation_risk": {
- "type": "string"
- },
- "recommendation": {
- "type": "string"
- },
- "risk": {
- "type": "string"
- },
- "row_count": {
- "type": [
- "number",
- "string"
- ]
- },
- "target": {
- "additionalProperties": true,
- "properties": {
- "action": {
- "type": "string"
- },
- "column": {
- "type": "string"
- },
- "object_type": {
- "type": "string"
- },
- "table": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "target_table": {
- "type": "string"
- }
- },
- "required": [
- "target_table"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "affected_views": {
+ "items": {},
+ "type": "array"
+ },
+ "analysis_scope": {
+ "enum": [
+ "table",
+ "column"
+ ],
+ "type": "string"
+ },
+ "dependency_risk": {
+ "type": "string"
+ },
+ "fk_dependencies": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "direction": {
+ "type": "string"
+ },
+ "references": {
+ "type": "string"
+ },
+ "references_column": {
+ "type": "string"
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "fk_dependencies_evaluated": {
+ "type": "boolean"
+ },
+ "intent": {
+ "type": "string"
+ },
+ "operation_risk": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "risk": {
+ "type": "string"
+ },
+ "row_count": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "target": {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "column": {
+ "type": "string"
+ },
+ "object_type": {
+ "type": "string"
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "target_table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "target_table"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]list_connections1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "createdAt": {
- "type": [
- "string",
- "number",
- "null"
- ]
- },
- "dbType": {
- "anyOf": [
- {
- "enum": [
- "postgres",
- "mysql",
- "mssql"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
- ]
- },
- "id": {
- "type": "string"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "name",
- "id",
- "dbType"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "createdAt": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "dbType": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "dbType"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]optimize_query1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "node_types": {
- "items": {
- "type": "string"
- },
- "type": "array"
- },
- "original_query": {
- "type": "string"
- },
- "recommendations": {
- "items": {},
- "type": "array"
- },
- "verdict": {
- "type": "string"
- }
- },
- "required": [
- "verdict"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "node_types": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "original_query": {
+ "type": "string"
+ },
+ "recommendations": {
+ "items": {},
+ "type": "array"
+ },
+ "verdict": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "verdict"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]pii_scan1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "column": {
- "type": "string"
- },
- "kind": {
- "type": "string"
- },
- "sample_matches": {
- "type": [
- "number",
- "string"
- ]
- },
- "sampled_rows": {
- "$ref": "#/properties/data/anyOf/0/items/properties/sample_matches"
- },
- "severity": {
- "anyOf": [
- {
- "enum": [
- "info",
- "warning",
- "critical"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
- ]
- },
- "table": {
- "type": "string"
- }
- },
- "required": [
- "table",
- "column",
- "kind",
- "severity"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "sample_matches": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "sampled_rows": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/sample_matches"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "table",
+ "column",
+ "kind",
+ "severity"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]query_firewall1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "action": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "name": {
- "type": "string"
- },
- "pattern": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "action": {
- "type": "string"
- },
- "added": {
- "type": "boolean"
- },
- "message": {
- "type": "string"
- },
- "name": {
- "type": "string"
- },
- "pattern": {
- "type": "string"
- },
- "rule_name": {
- "type": "string"
- }
- },
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "action": {
- "type": "string"
- },
- "allowed": {
- "type": "boolean"
- },
- "matched": {
- "type": "boolean"
- },
- "matched_rule": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "rule": {
- "type": [
- "string",
- "null"
- ]
- }
- },
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "added": {
+ "type": "boolean"
+ },
+ "message": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ },
+ "rule_name": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "allowed": {
+ "type": "boolean"
+ },
+ "matched": {
+ "type": "boolean"
+ },
+ "matched_rule": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "rule": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]query_history1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "error": {
- "type": [
- "string",
- "null"
- ]
- },
- "execution_ms": {
- "type": [
- "number",
- "string"
- ]
- },
- "rows": {
- "$ref": "#/properties/data/anyOf/0/items/properties/execution_ms"
- },
- "sql": {
- "type": "string"
- },
- "time": {
- "type": [
- "string",
- "number",
- "null"
- ]
- },
- "tool": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "error": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "execution_ms": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "rows": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/execution_ms"
+ },
+ "sql": {
+ "type": "string"
+ },
+ "time": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]query_sql1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]saved_queries1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "created": {
- "type": "string"
- },
- "description": {
- "type": "string"
- },
- "name": {
- "type": "string"
- },
- "runs": {
- "type": [
- "number",
- "string"
- ]
- },
- "tags": {
- "type": "string"
- }
- },
- "required": [
- "name"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "id": {
- "type": "string"
- },
- "name": {
- "type": "string"
- }
- },
- "required": [
- "id",
- "name"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "deleted": {
- "type": "string"
- }
- },
- "required": [
- "deleted"
- ],
- "type": "object"
- },
- {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "created": {
+ "type": "string"
+ },
+ "description": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "runs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "tags": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "id",
+ "name"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "deleted": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "deleted"
+ ],
+ "type": "object"
+ },
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]show_locks1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": {},
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]suggest_queries1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "category": {
- "type": "string"
- },
- "question": {
- "type": "string"
- },
- "sql": {
- "type": "string"
- }
- },
- "required": [
- "question",
- "sql"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "question": {
+ "type": "string"
+ },
+ "sql": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "question",
+ "sql"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]test_connection1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "current_database": {
- "type": [
- "string",
- "null"
- ]
- },
- "current_schema": {
- "type": [
- "string",
- "null"
- ]
- },
- "db_type": {
- "type": "string"
- },
- "ok": {
- "type": "boolean"
- },
- "ping_ms": {
- "type": [
- "number",
- "string"
- ]
- },
- "total_ms": {
- "$ref": "#/properties/data/anyOf/0/properties/ping_ms"
- },
- "version": {
- "type": "string"
- }
- },
- "required": [
- "ok"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "current_database": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "current_schema": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "db_type": {
+ "type": "string"
+ },
+ "ok": {
+ "type": "boolean"
+ },
+ "ping_ms": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "total_ms": {
+ "$ref": "#/properties/data/anyOf/0/properties/ping_ms"
+ },
+ "version": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "ok"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]watch_table1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "baseline": {
- "type": "boolean"
- },
- "current_count": {
- "type": [
- "number",
- "string"
- ]
- },
- "latest_record": {
- "type": [
- "string",
- "number",
- "null"
- ]
- },
- "table": {
- "type": "string"
- }
- },
- "required": [
- "table"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "baseline": {
+ "type": "boolean"
+ },
+ "current_count": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "latest_record": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "table"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "required": [
+ "error"
+ ],
+ "type": "object"
+ }
+]detect_anomalies1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "items": {
- "additionalProperties": true,
- "properties": {
- "column": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "recommendation": {
- "type": "string"
- },
- "severity": {
- "anyOf": [
- {
- "enum": [
- "info",
- "low",
- "medium",
- "high",
- "warning",
- "critical"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
- ]
- },
- "type": {
- "type": "string"
- },
- "value": {}
- },
- "required": [
- "severity"
- ],
- "type": "object"
- },
- "type": "array"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "message": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "low",
+ "medium",
+ "high",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "type": {
+ "type": "string"
+ },
+ "value": {}
+ },
+ "required": [
+ "severity"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+]impact_analysis1 field changedOutput schema / properties / data / anyOfPrevious value: -[
- {
- "additionalProperties": true,
- "properties": {
- "affected_views": {
- "items": {},
- "type": "array"
- },
- "fk_dependencies": {
- "items": {
- "additionalProperties": true,
- "properties": {
- "column": {
- "type": "string"
- },
- "references": {
- "type": "string"
- },
- "table": {
- "type": "string"
- }
- },
- "type": "object"
- },
- "type": "array"
- },
- "intent": {
- "type": "string"
- },
- "recommendation": {
- "type": "string"
- },
- "risk": {
- "type": "string"
- },
- "row_count": {
- "type": [
- "number",
- "string"
- ]
- },
- "target_table": {
- "type": "string"
- }
- },
- "required": [
- "target_table"
- ],
- "type": "object"
- },
- {
- "additionalProperties": true,
- "properties": {
- "code": {
- "type": "string"
- },
- "details": {
- "additionalProperties": {},
- "type": "object"
- },
- "error": {
- "type": "string"
- },
- "internal_code": {
- "type": "string"
- },
- "message": {
- "type": "string"
- },
- "retry_after_s": {
- "type": "number"
- }
- },
- "type": "object"
- }
-]New value: +[
+ {
+ "additionalProperties": true,
+ "properties": {
+ "affected_views": {
+ "items": {},
+ "type": "array"
+ },
+ "analysis_scope": {
+ "enum": [
+ "table",
+ "column"
+ ],
+ "type": "string"
+ },
+ "dependency_risk": {
+ "type": "string"
+ },
+ "fk_dependencies": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "direction": {
+ "type": "string"
+ },
+ "references": {
+ "type": "string"
+ },
+ "references_column": {
+ "type": "string"
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "fk_dependencies_evaluated": {
+ "type": "boolean"
+ },
+ "intent": {
+ "type": "string"
+ },
+ "operation_risk": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "risk": {
+ "type": "string"
+ },
+ "row_count": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "target": {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "column": {
+ "type": "string"
+ },
+ "object_type": {
+ "type": "string"
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "target_table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "target_table"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+]add_connection1 field changedOutput schema / properties / status / enumPrevious value: -[
- "link_issued",
- "over_cap"
-]New value: +[
+ "link_issued",
+ "over_cap",
+ "forbidden_scope"
+]remove_connection1 field changedOutput schema / properties / status / enumPrevious value: -[
- "removed",
- "not_found"
-]New value: +[
+ "removed",
+ "not_found",
+ "forbidden_scope"
+]issue_api_key3 fields changedOutput schema / properties / previous_keys_retire_atAdded value: +{
+ "description": "ISO 8601 instant when the previous keys stop working (one hour after this mint). Present only when previous_keys_retiring > 0. Update anything still using them before this time.",
+ "type": "string"
+}Output schema / properties / previous_keys_retiringAdded value: +{
+ "description": "How many previously-live keys this mint scheduled to retire. issue_api_key rotates: after the grace window the returned key is the only live key on the tenant. 0 means there was nothing else.",
+ "minimum": 0,
+ "type": "integer"
+}Output schema / properties / revoked_previousRemoved value: -{
- "description": "How many previously-live keys this mint revoked. issue_api_key rotates: the returned key is the only live key on the tenant. 0 means there was nothing else to revoke.",
- "minimum": 0,
- "type": "integer"
-}issue_api_key1 field changedOutput schema / properties / revoked_previousAdded value: +{
+ "description": "How many previously-live keys this mint revoked. issue_api_key rotates: the returned key is the only live key on the tenant. 0 means there was nothing else to revoke.",
+ "minimum": 0,
+ "type": "integer"
+}add_connectionanalyze_table3 fields changedInput schema / properties / column / maxLengthAdded value: +256Input schema / properties / connection / maxLengthAdded value: +256Input schema / properties / table / maxLengthAdded value: +256configure_allowlistcross_db_query2 fields changedInput schema / properties / connections / items / maxLengthAdded value: +256Input schema / properties / sql / maxLengthAdded value: +50000data_profile2 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / table / maxLengthAdded value: +256describe_schema1 field changedInput schema / properties / connection / maxLengthAdded value: +256detect_anomalies3 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / date_column / maxLengthAdded value: +256Input schema / properties / table / maxLengthAdded value: +256explain_query2 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / sql / maxLengthAdded value: +50000find_n_plus_one3 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / min_executions / maximumAdded value: +1000000Input schema / properties / min_executions / minimumAdded value: +1generate_migration3 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / intent / descriptionPrevious value: -"Plain English: 'add soft delete to users', 'add index on trips.driver_id'"New value: +"Plain English: 'add soft delete to drivers', 'add index on trips.driver_id'"Input schema / properties / intent / maxLengthAdded value: +2000generate_seed_data4 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / row_count / maximumAdded value: +1000Input schema / properties / row_count / minimumAdded value: +1Input schema / properties / table / maxLengthAdded value: +256impact_analysis3 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / intent / descriptionPrevious value: -"Describe the change: 'rename customer_id to account_id', 'drop column X'"New value: +"Describe the change: 'rename vehicle_id to vehicle_uuid on trips', 'drop column X'"Input schema / properties / intent / maxLengthAdded value: +500optimize_query2 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / query / maxLengthAdded value: +50000pii_scan6 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / max_tables / maximumAdded value: +50Input schema / properties / max_tables / minimumAdded value: +1Input schema / properties / sample_rows / descriptionPrevious value: -"Rows sampled per table (default 20, cap 100)"New value: +"Rows sampled per table (default 20, cap 100; values < 5 are floored to 5)"Input schema / properties / sample_rows / maximumAdded value: +100Input schema / properties / sample_rows / minimumAdded value: +1query_firewall5 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / message / maxLengthAdded value: +500Input schema / properties / pattern / maxLengthAdded value: +2000Input schema / properties / rule_name / maxLengthAdded value: +256Input schema / properties / sql / maxLengthAdded value: +50000query_history3 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / limit / maximumAdded value: +100Input schema / properties / limit / minimumAdded value: +1query_sql4 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / limit / maximumAdded value: +1000Input schema / properties / limit / minimumAdded value: +1Input schema / properties / query / maxLengthAdded value: +50000remove_connectionsaved_queries8 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / description / maxLengthAdded value: +1000Input schema / properties / id / maxLengthAdded value: +256Input schema / properties / name / maxLengthAdded value: +256Input schema / properties / sql / maxLengthAdded value: +50000Input schema / properties / tag / maxLengthAdded value: +256Input schema / properties / tags / items / maxLengthAdded value: +256Input schema / properties / tags / maxItemsAdded value: +20show_locks1 field changedInput schema / properties / connection / maxLengthAdded value: +256suggest_queries2 fields changedInput schema / properties / connection / maxLengthAdded value: +256Input schema / properties / context / maxLengthAdded value: +500test_connection1 field changedInput schema / properties / connection / maxLengthAdded value: +256watch_table4 fields changedInput schema / properties / column / maxLengthAdded value: +256Input schema / properties / condition / maxLengthAdded value: +256Input schema / properties / connection / maxLengthAdded value: +256Input schema / properties / table / maxLengthAdded value: +256analyze_table2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]cross_db_query2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]data_profile2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]describe_schema2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]detect_anomalies2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]explain_query2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]find_n_plus_one2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]generate_migration2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]generate_seed_data2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]impact_analysis2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]list_connections2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]optimize_query2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]pii_scan2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]query_firewall2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]query_history2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]query_sql2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]saved_queries2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]show_locks2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]suggest_queries2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]test_connection2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]watch_table2 fields changedOutput schema / properties / display / properties / mapAdded value: +{
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "lat": {
+ "type": "string"
+ },
+ "lon": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}Output schema / properties / display / properties / type / anyOfPrevious value: -[
- {
- "enum": [
- "table",
- "chart",
- "metric",
- "code",
- "text",
- "list"
- ],
- "type": "string"
- },
- {
- "type": "string"
- }
-]New value: +[
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list",
+ "map"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+]quota3 fields changedOutput schema / properties / reset_atAdded value: +{
+ "type": "string"
+}Output schema / properties / schema_versionAdded value: +{
+ "type": "string"
+}Output schema / properties / upgrade_url / typePrevious value: -"string"New value: +[
+ "string",
+ "null"
+]issue_api_key1 field changedOutput schema / properties / api_key / descriptionPrevious value: -"One-time API key secret. Returned only on successful creation. Treat as a credential — never log, echo, or render in text channels."New value: +"One-time API key secret. Returned only on successful creation, in both structuredContent.api_key and content[0].text — save it immediately. The server stores only sha-256 of the secret; once this response is lost, the key is unrecoverable and must be rotated. Matches AWS IAM / Stripe / GitHub PAT one-time-reveal semantics."analyze_table1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "avg": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "cardinality_pct": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "distinct_count": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "earliest": {},
+ "latest": {},
+ "max": {},
+ "min": {},
+ "name": {
+ "type": "string"
+ },
+ "null_pct": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "top_values": {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}cross_db_query1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "connection": {
+ "type": "string"
+ },
+ "error": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "execution_ms": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/rows/anyOf/2"
+ },
+ "rows": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "type": "null"
+ },
+ {
+ "type": [
+ "number",
+ "string"
+ ]
+ }
+ ]
+ },
+ "sample": {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "connection"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/rows/anyOf/2"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/rows/anyOf/2"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}data_profile1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "cardinality": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "distinct_count": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "isPrimaryKey": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "null_pct": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "nullable": {
+ "type": "boolean"
+ },
+ "pii_risk": {
+ "type": "boolean"
+ },
+ "pii_type": {
+ "type": "string"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/null_pct"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}describe_schema1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "columns": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "details": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "defaultValue": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "isPrimaryKey": {
+ "type": "boolean"
+ },
+ "name": {
+ "type": "string"
+ },
+ "nullable": {
+ "type": "boolean"
+ },
+ "type": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "type"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "name": {
+ "type": "string"
+ },
+ "primaryKeys": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/columns"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/columns"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}detect_anomalies1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "low",
+ "medium",
+ "high",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "type": {
+ "type": "string"
+ },
+ "value": {}
+ },
+ "required": [
+ "severity"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}explain_query1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "original_sql": {
+ "type": "string"
+ },
+ "plan": {}
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}find_n_plus_one1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "executions": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "pattern": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/executions"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/executions"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}generate_migration1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "down_sql": {
+ "type": "string"
+ },
+ "intent": {
+ "type": "string"
+ },
+ "up_sql": {
+ "type": "string"
+ },
+ "warnings": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ },
+ "required": [
+ "up_sql"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}generate_seed_data1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {},
+ "type": "array"
+ }
+ ]
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}impact_analysis1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "affected_views": {
+ "items": {},
+ "type": "array"
+ },
+ "fk_dependencies": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "references": {
+ "type": "string"
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "intent": {
+ "type": "string"
+ },
+ "recommendation": {
+ "type": "string"
+ },
+ "risk": {
+ "type": "string"
+ },
+ "row_count": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "target_table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "target_table"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/properties/row_count"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/properties/row_count"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}issue_api_key1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "api_key": {
+ "description": "One-time API key secret. Returned only on successful creation. Treat as a credential — never log, echo, or render in text channels.",
+ "type": "string"
+ },
+ "credential_returned_once": {
+ "type": "boolean"
+ },
+ "error": {
+ "additionalProperties": false,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "code",
+ "message"
+ ],
+ "type": "object"
+ },
+ "key_id": {
+ "description": "Non-secret fingerprint of the issued key. Safe to log and surface in UI.",
+ "type": "string"
+ },
+ "note": {
+ "type": "string"
+ },
+ "plan": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ },
+ "status": {
+ "enum": [
+ "success",
+ "error"
+ ],
+ "type": "string"
+ },
+ "tenantId": {
+ "type": "string"
+ },
+ "usage": {
+ "type": "string"
+ },
+ "user": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "status"
+ ],
+ "type": "object"
+}list_connections1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "createdAt": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "dbType": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name",
+ "id",
+ "dbType"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}optimize_query1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "node_types": {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ },
+ "original_query": {
+ "type": "string"
+ },
+ "recommendations": {
+ "items": {},
+ "type": "array"
+ },
+ "verdict": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "verdict"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}pii_scan1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "kind": {
+ "type": "string"
+ },
+ "sample_matches": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "sampled_rows": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/sample_matches"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "table",
+ "column",
+ "kind",
+ "severity"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/sample_matches"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/sample_matches"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}query_firewall1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "added": {
+ "type": "boolean"
+ },
+ "message": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "pattern": {
+ "type": "string"
+ },
+ "rule_name": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "action": {
+ "type": "string"
+ },
+ "allowed": {
+ "type": "boolean"
+ },
+ "matched": {
+ "type": "boolean"
+ },
+ "matched_rule": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "rule": {
+ "type": [
+ "string",
+ "null"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}query_history1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "error": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "execution_ms": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "rows": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/execution_ms"
+ },
+ "sql": {
+ "type": "string"
+ },
+ "time": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "tool": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/execution_ms"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/execution_ms"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}query_sql1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}quota1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "limit": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {
+ "type": "string"
+ },
+ "upgrade_url": {
+ "type": "string"
+ },
+ "used": {
+ "type": [
+ "number",
+ "string"
+ ]
+ }
+ },
+ "required": [
+ "used",
+ "limit",
+ "plan"
+ ],
+ "type": "object"
+}saved_queries1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "created": {
+ "type": "string"
+ },
+ "description": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ },
+ "runs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "tags": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "name"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "id": {
+ "type": "string"
+ },
+ "name": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "id",
+ "name"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "deleted": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "deleted"
+ ],
+ "type": "object"
+ },
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/runs"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/items/properties/runs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}show_locks1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}suggest_queries1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "category": {
+ "type": "string"
+ },
+ "question": {
+ "type": "string"
+ },
+ "sql": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "question",
+ "sql"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/meta/properties/executionTimeMs"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}test_connection1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "current_database": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "current_schema": {
+ "type": [
+ "string",
+ "null"
+ ]
+ },
+ "db_type": {
+ "type": "string"
+ },
+ "ok": {
+ "type": "boolean"
+ },
+ "ping_ms": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "total_ms": {
+ "$ref": "#/properties/data/anyOf/0/properties/ping_ms"
+ },
+ "version": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "ok"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/properties/ping_ms"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/properties/ping_ms"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}watch_table1 field changedOutput schema / (root)Previous value: -nullNew value: +{
+ "$schema": "http://json-schema.org/draft-07/schema#",
+ "additionalProperties": true,
+ "properties": {
+ "data": {
+ "anyOf": [
+ {
+ "additionalProperties": true,
+ "properties": {
+ "baseline": {
+ "type": "boolean"
+ },
+ "current_count": {
+ "type": [
+ "number",
+ "string"
+ ]
+ },
+ "latest_record": {
+ "type": [
+ "string",
+ "number",
+ "null"
+ ]
+ },
+ "table": {
+ "type": "string"
+ }
+ },
+ "required": [
+ "table"
+ ],
+ "type": "object"
+ },
+ {
+ "additionalProperties": true,
+ "properties": {
+ "code": {
+ "type": "string"
+ },
+ "details": {
+ "additionalProperties": {},
+ "type": "object"
+ },
+ "error": {
+ "type": "string"
+ },
+ "internal_code": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "retry_after_s": {
+ "type": "number"
+ }
+ },
+ "type": "object"
+ }
+ ]
+ },
+ "display": {
+ "additionalProperties": true,
+ "properties": {
+ "chart": {
+ "additionalProperties": true,
+ "properties": {
+ "chartType": {
+ "type": "string"
+ },
+ "color": {
+ "type": "string"
+ },
+ "title": {
+ "type": "string"
+ },
+ "x": {
+ "type": "string"
+ },
+ "xLabel": {
+ "type": "string"
+ },
+ "y": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "items": {
+ "type": "string"
+ },
+ "type": "array"
+ }
+ ]
+ },
+ "yLabel": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "code": {
+ "additionalProperties": true,
+ "properties": {
+ "executable": {
+ "type": "boolean"
+ },
+ "language": {
+ "anyOf": [
+ {
+ "enum": [
+ "sql",
+ "json",
+ "bash",
+ "typescript"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "title": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+ },
+ "metric": {
+ "additionalProperties": true,
+ "properties": {
+ "label": {
+ "type": "string"
+ },
+ "status": {
+ "anyOf": [
+ {
+ "enum": [
+ "good",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trend": {
+ "anyOf": [
+ {
+ "enum": [
+ "up",
+ "down",
+ "neutral"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "trendValue": {
+ "type": "string"
+ },
+ "unit": {
+ "type": "string"
+ },
+ "value": {
+ "type": [
+ "string",
+ "number"
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "type": {
+ "anyOf": [
+ {
+ "enum": [
+ "table",
+ "chart",
+ "metric",
+ "code",
+ "text",
+ "list"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ }
+ },
+ "type": "object"
+ },
+ "insights": {
+ "items": {
+ "additionalProperties": true,
+ "properties": {
+ "column": {
+ "type": "string"
+ },
+ "message": {
+ "type": "string"
+ },
+ "severity": {
+ "anyOf": [
+ {
+ "enum": [
+ "info",
+ "warning",
+ "critical"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "value": {}
+ },
+ "required": [
+ "severity",
+ "message"
+ ],
+ "type": "object"
+ },
+ "type": "array"
+ },
+ "meta": {
+ "additionalProperties": true,
+ "properties": {
+ "cacheHit": {
+ "type": "boolean"
+ },
+ "connection": {
+ "type": "string"
+ },
+ "dialect": {
+ "anyOf": [
+ {
+ "enum": [
+ "postgres",
+ "mysql",
+ "mssql"
+ ],
+ "type": "string"
+ },
+ {
+ "type": "string"
+ }
+ ]
+ },
+ "executionTimeMs": {
+ "$ref": "#/properties/data/anyOf/0/properties/current_count"
+ },
+ "plan": {},
+ "rowCount": {
+ "$ref": "#/properties/data/anyOf/0/properties/current_count"
+ },
+ "tool": {
+ "type": "string"
+ },
+ "truncated": {
+ "type": "boolean"
+ }
+ },
+ "type": "object"
+ },
+ "summary": {
+ "type": "string"
+ }
+ },
+ "type": "object"
+}analyze_tablecross_db_querydata_profiledescribe_schemadetect_anomaliesexplain_queryfind_n_plus_onegenerate_migrationgenerate_seed_dataimpact_analysisissue_api_keylist_connectionsoptimize_querypii_scanquery_firewallquery_historyquery_sqlquotasaved_queriesshow_lockssuggest_queriestest_connectionwatch_table
Add one secure layer between your agents and this server.