com.exoquery/mcp-server

{
  "checks": {
    "action_safety_probe": {
      "details": {
        "auth_present": true,
        "confirmation_signals": [],
        "safeguard_count": 1,
        "summary": {
          "bulk_access_tools": 0,
          "capability_distribution": {
            "admin": 5,
            "delete": 5,
            "exec": 5,
            "filesystem": 4,
            "network": 2,
            "read": 6,
            "write": 5
          },
          "destructive_tools": 5,
          "egress_tools": 0,
          "exec_tools": 5,
          "high_risk_tools": 5,
          "risk_distribution": {
            "critical": 5,
            "high": 0,
            "low": 1,
            "medium": 0
          },
          "secret_tools": 0,
          "tool_count": 6
        }
      },
      "latency_ms": null,
      "status": "warning"
    },
    "advanced_capabilities_probe": {
      "details": {
        "capabilities": {
          "completions": true,
          "elicitation": false,
          "prompts": true,
          "resource_links": false,
          "resources": true,
          "roots": false,
          "sampling": false,
          "structured_outputs": false
        },
        "enabled": [
          "completions",
          "prompts",
          "resources"
        ],
        "enabled_count": 3,
        "initialize_capability_keys": [
          "completions",
          "prompts",
          "resources",
          "tools"
        ]
      },
      "latency_ms": null,
      "status": "warning"
    },
    "connector_publishability_probe": {
      "details": {
        "blockers": [
          "transport_compliance",
          "server_card"
        ],
        "criteria": {
          "action_safety": true,
          "auth_flow": true,
          "connector_replay": true,
          "initialize": true,
          "protocol_version": true,
          "remote_transport": true,
          "request_association": true,
          "server_card": false,
          "session_resume": true,
          "step_up_auth": true,
          "tool_surface": true,
          "tools_list": true,
          "transport_compliance": false
        },
        "high_risk_tools": 5,
        "tool_count": 6,
        "transport": "streamable-http"
      },
      "latency_ms": null,
      "status": "warning"
    },
    "connector_replay_probe": {
      "details": {
        "added_tools": [],
        "additive_output_changes": [],
        "backward_compatible": true,
        "output_breaks": [],
        "removed_tools": [],
        "required_arg_breaks": [],
        "would_break_after_refresh": false
      },
      "latency_ms": null,
      "status": "ok"
    },
    "determinism_probe": {
      "details": {
        "attempts": 2,
        "baseline_signature": "a605b09b132fce76ad210533bb79e99eb23e85baf0b1b448c4b024ff3cc6f9dd",
        "errors": [],
        "matches": 2,
        "stable_ratio": 1.0,
        "successful": 2
      },
      "latency_ms": 45.2,
      "status": "ok"
    },
    "initialize": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "id": 1,
          "jsonrpc": "2.0",
          "result": {
            "capabilities": {
              "completions": {},
              "prompts": {
                "listChanged": false
              },
              "resources": {
                "listChanged": false,
                "subscribe": false
              },
              "tools": {
                "listChanged": false
              }
            },
            "protocolVersion": "2025-03-26",
            "serverInfo": {
              "name": "exoquery-mcp",
              "version": "1.0.0"
            }
          }
        },
        "url": "https://backend.exoquery.com/mcp"
      },
      "latency_ms": 44.27,
      "status": "ok"
    },
    "interactive_flow_probe": {
      "details": {
        "oauth_supported": true,
        "prompt_available": false,
        "risk_hits": [],
        "safe_hits": []
      },
      "latency_ms": null,
      "status": "ok"
    },
    "oauth_authorization_server": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "authorization_endpoint": "https://backend.exoquery.com/oauth/authorize",
          "code_challenge_methods_supported": [
            "S256"
          ],
          "grant_types_supported": [
            "authorization_code",
            "refresh_token"
          ],
          "issuer": "https://backend.exoquery.com",
          "jwks_uri": "https://backend.exoquery.com/oauth/jwks",
          "registration_endpoint": "https://backend.exoquery.com/oauth/register",
          "response_types_supported": [
            "code"
          ],
          "scopes_supported": [
            "mcp"
          ],
          "token_endpoint": "https://backend.exoquery.com/oauth/token",
          "token_endpoint_auth_methods_supported": [
            "none",
            "client_secret_post"
          ]
        },
        "url": "https://backend.exoquery.com/.well-known/oauth-authorization-server"
      },
      "latency_ms": 51.57,
      "status": "ok"
    },
    "oauth_protected_resource": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "authorization_servers": [
            "https://backend.exoquery.com"
          ],
          "resource": "https://backend.exoquery.com"
        },
        "url": "https://backend.exoquery.com/.well-known/oauth-protected-resource"
      },
      "latency_ms": 51.5,
      "status": "ok"
    },
    "official_registry_probe": {
      "details": {
        "direct_match": true,
        "official_peer_count": 1,
        "registry_identifier": "com.exoquery/mcp-server",
        "registry_source": "official_registry"
      },
      "latency_ms": null,
      "status": "ok"
    },
    "openid_configuration": {
      "details": {
        "error": "Client error '403 Forbidden' for url 'https://backend.exoquery.com/.well-known/openid-configuration'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403",
        "url": "https://backend.exoquery.com/.well-known/openid-configuration"
      },
      "latency_ms": 17.11,
      "status": "error"
    },
    "probe_noise_resilience": {
      "details": {
        "headers": {
          "content-type": "application/json"
        },
        "http_status": 403,
        "url": "https://backend.exoquery.com/robots.txt"
      },
      "latency_ms": 19.19,
      "status": "error"
    },
    "prompt_get": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "prompts_list": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "id": 3,
          "jsonrpc": "2.0",
          "result": {
            "prompts": []
          }
        },
        "url": "https://backend.exoquery.com/mcp"
      },
      "latency_ms": 37.22,
      "status": "ok"
    },
    "protocol_version_probe": {
      "details": {
        "claimed_version": "2025-03-26",
        "lag_days": 244,
        "latest_known_version": "2025-11-25",
        "releases_behind": 2,
        "validator_protocol_version": "2025-03-26"
      },
      "latency_ms": null,
      "status": "warning"
    },
    "provenance_divergence_probe": {
      "details": {
        "direct_official_match": true,
        "drift_fields": [],
        "metadata_document_count": 1,
        "registry_homepage": null,
        "registry_repository": null,
        "registry_title": null,
        "registry_version": null,
        "server_card_homepage": null,
        "server_card_repository": null,
        "server_card_title": null,
        "server_card_version": null
      },
      "latency_ms": null,
      "status": "ok"
    },
    "request_association_probe": {
      "details": {
        "reason": "no_request_association_capabilities_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resource_read": {
      "details": {
        "reason": "not_advertised"
      },
      "latency_ms": null,
      "status": "missing"
    },
    "resources_list": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "id": 5,
          "jsonrpc": "2.0",
          "result": {
            "resources": []
          }
        },
        "url": "https://backend.exoquery.com/mcp"
      },
      "latency_ms": 39.4,
      "status": "ok"
    },
    "server_card": {
      "details": {
        "error": "Client error '403 Forbidden' for url 'https://backend.exoquery.com/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403",
        "url": "https://backend.exoquery.com/.well-known/mcp/server-card.json"
      },
      "latency_ms": 111.11,
      "status": "error"
    },
    "session_resume_probe": {
      "details": {
        "protocol_version": "2025-03-26",
        "reason": "no_session_id",
        "resume_expected": true,
        "transport": "streamable-http"
      },
      "latency_ms": null,
      "status": "warning"
    },
    "step_up_auth_probe": {
      "details": {
        "auth_required_checks": [],
        "broad_scopes": [],
        "challenge_headers": [],
        "minimal_scope_documented": true,
        "oauth_present": true,
        "scope_specificity_ratio": 0.5,
        "step_up_signals": [],
        "supported_scopes": [
          "mcp"
        ]
      },
      "latency_ms": null,
      "status": "ok"
    },
    "tool_snapshot_probe": {
      "details": {
        "added": [],
        "changed_outputs": [],
        "current_tool_count": 6,
        "previous_tool_count": 6,
        "removed": [],
        "similarity": 1.0
      },
      "latency_ms": null,
      "status": "ok"
    },
    "tools_list": {
      "details": {
        "headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "http_status": 200,
        "payload": {
          "id": 2,
          "jsonrpc": "2.0",
          "result": {
            "tools": [
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nAccess comprehensive ExoQuery documentation organized by topic and category.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nAVAILABLE DOCUMENTATION CATEGORIES:\n\n1. **Getting Started**\n   - Introduction: What ExoQuery is and why it exists\n   - Installation: Project setup and dependencies\n   - Quick Start: First query in minutes\n\n2. **Core Concepts**\n   - SQL Blocks: The sql { } construct and query building\n   - Parameters: Safe runtime data handling\n   - Composing Queries: Functional query composition\n\n3. **Query Operations**\n   - Basic Operations: Map, filter, and transformations\n   - Joins: Inner, left, and implicit joins\n   - Grouping: GROUP BY and HAVING clauses\n   - Sorting: ORDER BY operations\n   - Subqueries: Correlated and nested queries\n   - Window Functions: Advanced analytics\n\n4. **Actions**\n   - Insert: INSERT with returning and conflict handling\n   - Update: UPDATE operations with setParams\n   - Delete: DELETE with returning\n   - Batch Operations: Bulk inserts and updates\n\n5. **Advanced Features**\n   - SQL Fragment Functions: Reusable SQL components with @SqlFragment\n   - Dynamic Queries: Runtime query generation with @SqlDynamic\n   - Free Blocks: Custom SQL and user-defined functions\n   - Transactions: Transaction support patterns\n   - Polymorphic Queries: Interfaces, sealed classes, higher-order functions\n   - Local Variables: Variables within SQL blocks\n\n6. **Data Handling**\n   - Serialization: kotlinx.serialization integration\n   - Custom Type Encoding: Custom encoders and decoders\n   - JSON Columns: JSON and JSONB support (PostgreSQL)\n   - Column Naming: @SerialName and @ExoEntity annotations\n   - Nested Datatypes: Complex data structures\n   - Kotlinx Integration: JSON and other serialization formats\n\n7. **Schema-First Development**\n   - Entity Generation: Compile-time code generation from database schema\n   - AI-Enhanced Entities: Using LLMs to generate cleaner entity code\n\n8. **Reference**\n   - SQL Functions: Available string, math, and date functions\n   - API Reference: Core types and function signatures\n\nHOW TO USE THIS RESOURCE:\n\nThe resource URI follows the pattern:\n  exoquery://docs/{file-path}\n\nWhere {file-path} is the relative path from the docs root, e.g.:\n  - exoquery://docs/01-getting-started/01-introduction.md\n  - exoquery://docs/03-query-operations/02-joins.md\n  - exoquery://docs/05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about ExoQuery syntax, features, or capabilities\n- User needs examples of specific query patterns\n- User encounters errors and needs to verify correct usage\n- User wants to understand advanced features or best practices\n",
                "inputSchema": {
                  "properties": {
                    "filePath": {
                      "description": "\nThe documentation file path to retrieve.\n\nFormat: Relative path from docs root (e.g., \"01-getting-started/01-introduction.md\")\n\nThe full URI is: exoquery://docs/{file-path}\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "filePath"
                  ],
                  "type": "object"
                },
                "name": "getExoQueryDocs",
                "title": "getExoQueryDocs"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nAccess multiple ExoQuery documentation sections simultaneously.\n\nThis tool is similar to the single-document retrieval tool but allows fetching multiple documentation files in a single request. This is particularly useful when you need to gather information from several related topics at once.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nHOW TO USE THIS RESOURCE:\n\nProvide a list of file paths, where each path is the relative path from the docs root, e.g.:\n  - 01-getting-started/01-introduction.md\n  - 03-query-operations/02-joins.md\n  - 05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach returned document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about multiple ExoQuery topics that require information from different sections\n- User needs to compare or understand relationships between different features\n- User wants to get comprehensive information across multiple categories\n- More efficient than making multiple single-document requests\n",
                "inputSchema": {
                  "properties": {
                    "filePaths": {
                      "description": "\nA list of documentation file paths to retrieve.\n\nFormat: List of relative paths from docs root (e.g., [\"01-getting-started/01-introduction.md\", \"03-query-operations/02-joins.md\"])\n\nEach path follows the pattern used in single-document retrieval: {category-folder}/{file-name}.md\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "filePaths"
                  ],
                  "type": "object"
                },
                "name": "getExoQueryDocsMulti",
                "title": "getExoQueryDocsMulti"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "Lists all available ExoQuery documentation resources with their metadata",
                "inputSchema": {
                  "properties": {},
                  "required": [],
                  "type": "object"
                },
                "name": "listExoQueryDocs",
                "title": "listExoQueryDocs"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nExecute raw, client-provided SQL queries against an ephemeral database initialized with the provided schema.\nReturns query results in a simple JSON format with column headers and row data as a 2D array.\n\nThe database type (SQLite or Postgres) is specified via the databaseType parameter:\n- SQLITE: In-memory, lightweight, uses standard SQLite syntax\n- POSTGRES: Temporary isolated schema with dedicated user, uses PostgreSQL syntax and features\n\nWHEN TO USE: When you need to run your own hand-written SQL queries to test database behavior or\ncompare the output with ExoQuery results from validateAndRunExoquery. This lets you verify that\nExoQuery-generated SQL produces the same results as your expected SQL.\n\nINPUT REQUIREMENTS:\n- query: A valid SQL query (SELECT, INSERT, UPDATE, DELETE, etc.)\n- schema: SQL schema with CREATE TABLE and INSERT statements to initialize the test database\n- databaseType: Either \"SQLITE\" or \"POSTGRES\" (defaults to SQLITE if not specified)\n\nOUTPUT FORMAT:\n\nOn success, returns JSON with the SQL query and a 2D array of results:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nOutput format details:\n- First array element contains column headers\n- Subsequent array elements contain row data\n- All values are returned as strings\n\nOn error, returns JSON with error message and the attempted query (if available):\n{\"error\":\"Query execution failed: no such table: USERS\",\"sql\":\"SELECT * FROM USERS\"}\n\nOr if schema initialization fails:\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users ...\\\\n--------\",\"sql\":\"CREAT TABLE users ...\"}\n\nEXAMPLE INPUT:\n\nQuery:\nSELECT * FROM users ORDER BY id\n\nSchema:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nEXAMPLE ERROR OUTPUT (bad table name):\n{\"error\":\"Query execution failed: no such table: invalid_table\",\"sql\":\"SELECT * FROM invalid_table\"}\n\nEXAMPLE ERROR OUTPUT (bad schema):\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users (id INTEGER)\\\\n--------\\\\nCheck that the initialization SQL is valid and compatible with SQLite.\",\"sql\":\"CREAT TABLE users (id INTEGER)\"}\n\nCOMMON QUERY EXAMPLES:\n\nSelect all rows:\nSELECT * FROM users\n\nSelect specific columns with filtering:\nSELECT name, age FROM users WHERE age > 25\n\nAggregate functions:\nSELECT COUNT(*) as total FROM users\n\nJoin queries:\nSELECT u.name, o.total FROM users u JOIN orders o ON u.id = o.user_id\n\nInsert data:\nINSERT INTO users (name, age) VALUES ('David', 40)\n\nUpdate data:\nUPDATE users SET age = 31 WHERE name = 'Alice'\n\nDelete data:\nDELETE FROM users WHERE age < 25\n\nCount with grouping:\nSELECT age, COUNT(*) as count FROM users GROUP BY age\n\nSCHEMA RULES:\n- Use standard SQLite syntax\n- Table names are case-sensitive (use lowercase for simplicity or quote names)\n- Include INSERT statements to populate test data for meaningful results\n- Supported data types: INTEGER, TEXT, REAL, BLOB, NULL\n- Use INTEGER PRIMARY KEY for auto-increment columns\n- Schema SQL is split on semicolons (;), so each statement after a ';' is executed separately\n- Avoid semicolons in comments as they will cause statement parsing issues\n\nCOMPARISON WITH EXOQUERY:\nThis tool is designed to work alongside validateAndRunExoquery for comparison purposes:\n1. Use validateAndRunExoquery to run ExoQuery Kotlin code and see the generated SQL + results\n2. Use runRawSql with your own hand-written SQL to verify you get the same output\n3. Compare the outputs to ensure ExoQuery generates the SQL you expect\n4. Test edge cases with plain SQL before writing equivalent ExoQuery code\n",
                "inputSchema": {
                  "properties": {
                    "query": {
                      "description": "\nA valid SQL query to execute against the database.\n\nCan be any valid SQL statement (syntax depends on databaseType parameter):\n- SELECT queries (with WHERE, JOIN, GROUP BY, ORDER BY, LIMIT, etc.)\n- INSERT statements\n- UPDATE statements\n- DELETE statements\n- DDL statements like CREATE/ALTER/DROP (applied after schema initialization)\n\nThe query will be executed against a database initialized with the provided schema parameter.\n\nExample:\nSELECT * FROM users WHERE age > 25 ORDER BY name\n",
                      "type": "string"
                    },
                    "schema": {
                      "description": "\nSQL schema to initialize the ephemeral test database.\n\nMust include:\n1. CREATE TABLE statements for all tables used in the query\n2. INSERT statements with test data\n\nUse syntax appropriate for the selected databaseType (SQLite or Postgres).\nTable names are case-sensitive. The schema is split on semicolons, so each statement is executed separately.\n\nExample:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "query",
                    "schema"
                  ],
                  "type": "object"
                },
                "name": "runRawSql",
                "title": "runRawSql"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
                "inputSchema": {
                  "properties": {
                    "code": {
                      "description": "\nComplete ExoQuery Kotlin code to compile and execute.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes that EXACTLY match your schema tables\n3. The query expression\n4. A main() function ending with .buildFor.<Dialect>().runSample()\n    This function MUST be present to trigger SQL generation and execution.\n\nUse @SerialName(\"column_name\") when Kotlin property names differ from SQL column names.\nUse @Contextual for BigDecimal fields.\nUse @SqlJsonValue on data classes that represent JSON column values.\n\nMultiple queries in main() will produce multiple output JSON objects.\n",
                      "type": "string"
                    },
                    "databaseType": {
                      "description": "Database type: SQLITE or POSTGRES (default: SQLITE)",
                      "type": "string"
                    },
                    "schema": {
                      "description": "\nSQL schema to initialize the Sqlite test database.\n\nMust include:\n1. CREATE TABLE statements for all tables referenced in the query\n2. INSERT statements with test data to verify query behavior\n\nTable and column names must exactly match the data classes in the code.\nUse double quotes around table names to preserve case: CREATE TABLE \"User\" (...)\n\nCommon error: Table \"USER\" not found, means you wrote CREATE TABLE User but queried \"User\".\nAlways quote table names in schema to match ExoQuery's generated SQL.\n\nExample:\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nINSERT INTO \"User\" VALUES (1, 'Alice', 30), (2, 'Bob', 25);\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "code",
                    "schema"
                  ],
                  "type": "object"
                },
                "name": "validateAndRunExoquery",
                "title": "validateAndRunExoquery"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
                "inputSchema": {
                  "properties": {
                    "code": {
                      "description": "\nComplete ExoQuery Kotlin code to compile.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes matching your query entities\n3. The query expression using sql { ... } or sql.select { ... }\n4. A main() function ending with .buildFor.<Dialect>().runSample() or .buildPrettyFor.<Dialect>().runSample()\n   This function MUST be present to trigger SQL generation.\n\nThe runSample() function triggers SQL generation but does NOT execute the query for validateExoquery.\n(Note that this is NOT for production ExoQuery usage. For that you use `.runOn(database)`.)\n\nDialect is part of the code (e.g., .buildFor.Postgres()), NOT a separate parameter.\n\nIf compilation fails, check the error interval positions to locate the exact issue in your code.\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "code"
                  ],
                  "type": "object"
                },
                "name": "validateExoquery",
                "title": "validateExoquery"
              }
            ]
          }
        },
        "url": "https://backend.exoquery.com/mcp"
      },
      "latency_ms": 40.5,
      "status": "ok"
    },
    "transport_compliance_probe": {
      "details": {
        "bad_protocol_error": null,
        "bad_protocol_headers": {
          "content-type": "application/json",
          "strict-transport-security": "max-age=31536000 ; includeSubDomains"
        },
        "bad_protocol_payload": {
          "id": 410,
          "jsonrpc": "2.0",
          "result": {
            "tools": [
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nAccess comprehensive ExoQuery documentation organized by topic and category.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nAVAILABLE DOCUMENTATION CATEGORIES:\n\n1. **Getting Started**\n   - Introduction: What ExoQuery is and why it exists\n   - Installation: Project setup and dependencies\n   - Quick Start: First query in minutes\n\n2. **Core Concepts**\n   - SQL Blocks: The sql { } construct and query building\n   - Parameters: Safe runtime data handling\n   - Composing Queries: Functional query composition\n\n3. **Query Operations**\n   - Basic Operations: Map, filter, and transformations\n   - Joins: Inner, left, and implicit joins\n   - Grouping: GROUP BY and HAVING clauses\n   - Sorting: ORDER BY operations\n   - Subqueries: Correlated and nested queries\n   - Window Functions: Advanced analytics\n\n4. **Actions**\n   - Insert: INSERT with returning and conflict handling\n   - Update: UPDATE operations with setParams\n   - Delete: DELETE with returning\n   - Batch Operations: Bulk inserts and updates\n\n5. **Advanced Features**\n   - SQL Fragment Functions: Reusable SQL components with @SqlFragment\n   - Dynamic Queries: Runtime query generation with @SqlDynamic\n   - Free Blocks: Custom SQL and user-defined functions\n   - Transactions: Transaction support patterns\n   - Polymorphic Queries: Interfaces, sealed classes, higher-order functions\n   - Local Variables: Variables within SQL blocks\n\n6. **Data Handling**\n   - Serialization: kotlinx.serialization integration\n   - Custom Type Encoding: Custom encoders and decoders\n   - JSON Columns: JSON and JSONB support (PostgreSQL)\n   - Column Naming: @SerialName and @ExoEntity annotations\n   - Nested Datatypes: Complex data structures\n   - Kotlinx Integration: JSON and other serialization formats\n\n7. **Schema-First Development**\n   - Entity Generation: Compile-time code generation from database schema\n   - AI-Enhanced Entities: Using LLMs to generate cleaner entity code\n\n8. **Reference**\n   - SQL Functions: Available string, math, and date functions\n   - API Reference: Core types and function signatures\n\nHOW TO USE THIS RESOURCE:\n\nThe resource URI follows the pattern:\n  exoquery://docs/{file-path}\n\nWhere {file-path} is the relative path from the docs root, e.g.:\n  - exoquery://docs/01-getting-started/01-introduction.md\n  - exoquery://docs/03-query-operations/02-joins.md\n  - exoquery://docs/05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about ExoQuery syntax, features, or capabilities\n- User needs examples of specific query patterns\n- User encounters errors and needs to verify correct usage\n- User wants to understand advanced features or best practices\n",
                "inputSchema": {
                  "properties": {
                    "filePath": {
                      "description": "\nThe documentation file path to retrieve.\n\nFormat: Relative path from docs root (e.g., \"01-getting-started/01-introduction.md\")\n\nThe full URI is: exoquery://docs/{file-path}\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "filePath"
                  ],
                  "type": "object"
                },
                "name": "getExoQueryDocs",
                "title": "getExoQueryDocs"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nAccess multiple ExoQuery documentation sections simultaneously.\n\nThis tool is similar to the single-document retrieval tool but allows fetching multiple documentation files in a single request. This is particularly useful when you need to gather information from several related topics at once.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nHOW TO USE THIS RESOURCE:\n\nProvide a list of file paths, where each path is the relative path from the docs root, e.g.:\n  - 01-getting-started/01-introduction.md\n  - 03-query-operations/02-joins.md\n  - 05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach returned document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about multiple ExoQuery topics that require information from different sections\n- User needs to compare or understand relationships between different features\n- User wants to get comprehensive information across multiple categories\n- More efficient than making multiple single-document requests\n",
                "inputSchema": {
                  "properties": {
                    "filePaths": {
                      "description": "\nA list of documentation file paths to retrieve.\n\nFormat: List of relative paths from docs root (e.g., [\"01-getting-started/01-introduction.md\", \"03-query-operations/02-joins.md\"])\n\nEach path follows the pattern used in single-document retrieval: {category-folder}/{file-name}.md\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "filePaths"
                  ],
                  "type": "object"
                },
                "name": "getExoQueryDocsMulti",
                "title": "getExoQueryDocsMulti"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "Lists all available ExoQuery documentation resources with their metadata",
                "inputSchema": {
                  "properties": {},
                  "required": [],
                  "type": "object"
                },
                "name": "listExoQueryDocs",
                "title": "listExoQueryDocs"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nExecute raw, client-provided SQL queries against an ephemeral database initialized with the provided schema.\nReturns query results in a simple JSON format with column headers and row data as a 2D array.\n\nThe database type (SQLite or Postgres) is specified via the databaseType parameter:\n- SQLITE: In-memory, lightweight, uses standard SQLite syntax\n- POSTGRES: Temporary isolated schema with dedicated user, uses PostgreSQL syntax and features\n\nWHEN TO USE: When you need to run your own hand-written SQL queries to test database behavior or\ncompare the output with ExoQuery results from validateAndRunExoquery. This lets you verify that\nExoQuery-generated SQL produces the same results as your expected SQL.\n\nINPUT REQUIREMENTS:\n- query: A valid SQL query (SELECT, INSERT, UPDATE, DELETE, etc.)\n- schema: SQL schema with CREATE TABLE and INSERT statements to initialize the test database\n- databaseType: Either \"SQLITE\" or \"POSTGRES\" (defaults to SQLITE if not specified)\n\nOUTPUT FORMAT:\n\nOn success, returns JSON with the SQL query and a 2D array of results:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nOutput format details:\n- First array element contains column headers\n- Subsequent array elements contain row data\n- All values are returned as strings\n\nOn error, returns JSON with error message and the attempted query (if available):\n{\"error\":\"Query execution failed: no such table: USERS\",\"sql\":\"SELECT * FROM USERS\"}\n\nOr if schema initialization fails:\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users ...\\\\n--------\",\"sql\":\"CREAT TABLE users ...\"}\n\nEXAMPLE INPUT:\n\nQuery:\nSELECT * FROM users ORDER BY id\n\nSchema:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nEXAMPLE ERROR OUTPUT (bad table name):\n{\"error\":\"Query execution failed: no such table: invalid_table\",\"sql\":\"SELECT * FROM invalid_table\"}\n\nEXAMPLE ERROR OUTPUT (bad schema):\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users (id INTEGER)\\\\n--------\\\\nCheck that the initialization SQL is valid and compatible with SQLite.\",\"sql\":\"CREAT TABLE users (id INTEGER)\"}\n\nCOMMON QUERY EXAMPLES:\n\nSelect all rows:\nSELECT * FROM users\n\nSelect specific columns with filtering:\nSELECT name, age FROM users WHERE age > 25\n\nAggregate functions:\nSELECT COUNT(*) as total FROM users\n\nJoin queries:\nSELECT u.name, o.total FROM users u JOIN orders o ON u.id = o.user_id\n\nInsert data:\nINSERT INTO users (name, age) VALUES ('David', 40)\n\nUpdate data:\nUPDATE users SET age = 31 WHERE name = 'Alice'\n\nDelete data:\nDELETE FROM users WHERE age < 25\n\nCount with grouping:\nSELECT age, COUNT(*) as count FROM users GROUP BY age\n\nSCHEMA RULES:\n- Use standard SQLite syntax\n- Table names are case-sensitive (use lowercase for simplicity or quote names)\n- Include INSERT statements to populate test data for meaningful results\n- Supported data types: INTEGER, TEXT, REAL, BLOB, NULL\n- Use INTEGER PRIMARY KEY for auto-increment columns\n- Schema SQL is split on semicolons (;), so each statement after a ';' is executed separately\n- Avoid semicolons in comments as they will cause statement parsing issues\n\nCOMPARISON WITH EXOQUERY:\nThis tool is designed to work alongside validateAndRunExoquery for comparison purposes:\n1. Use validateAndRunExoquery to run ExoQuery Kotlin code and see the generated SQL + results\n2. Use runRawSql with your own hand-written SQL to verify you get the same output\n3. Compare the outputs to ensure ExoQuery generates the SQL you expect\n4. Test edge cases with plain SQL before writing equivalent ExoQuery code\n",
                "inputSchema": {
                  "properties": {
                    "query": {
                      "description": "\nA valid SQL query to execute against the database.\n\nCan be any valid SQL statement (syntax depends on databaseType parameter):\n- SELECT queries (with WHERE, JOIN, GROUP BY, ORDER BY, LIMIT, etc.)\n- INSERT statements\n- UPDATE statements\n- DELETE statements\n- DDL statements like CREATE/ALTER/DROP (applied after schema initialization)\n\nThe query will be executed against a database initialized with the provided schema parameter.\n\nExample:\nSELECT * FROM users WHERE age > 25 ORDER BY name\n",
                      "type": "string"
                    },
                    "schema": {
                      "description": "\nSQL schema to initialize the ephemeral test database.\n\nMust include:\n1. CREATE TABLE statements for all tables used in the query\n2. INSERT statements with test data\n\nUse syntax appropriate for the selected databaseType (SQLite or Postgres).\nTable names are case-sensitive. The schema is split on semicolons, so each statement is executed separately.\n\nExample:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "query",
                    "schema"
                  ],
                  "type": "object"
                },
                "name": "runRawSql",
                "title": "runRawSql"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
                "inputSchema": {
                  "properties": {
                    "code": {
                      "description": "\nComplete ExoQuery Kotlin code to compile and execute.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes that EXACTLY match your schema tables\n3. The query expression\n4. A main() function ending with .buildFor.<Dialect>().runSample()\n    This function MUST be present to trigger SQL generation and execution.\n\nUse @SerialName(\"column_name\") when Kotlin property names differ from SQL column names.\nUse @Contextual for BigDecimal fields.\nUse @SqlJsonValue on data classes that represent JSON column values.\n\nMultiple queries in main() will produce multiple output JSON objects.\n",
                      "type": "string"
                    },
                    "databaseType": {
                      "description": "Database type: SQLITE or POSTGRES (default: SQLITE)",
                      "type": "string"
                    },
                    "schema": {
                      "description": "\nSQL schema to initialize the Sqlite test database.\n\nMust include:\n1. CREATE TABLE statements for all tables referenced in the query\n2. INSERT statements with test data to verify query behavior\n\nTable and column names must exactly match the data classes in the code.\nUse double quotes around table names to preserve case: CREATE TABLE \"User\" (...)\n\nCommon error: Table \"USER\" not found, means you wrote CREATE TABLE User but queried \"User\".\nAlways quote table names in schema to match ExoQuery's generated SQL.\n\nExample:\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nINSERT INTO \"User\" VALUES (1, 'Alice', 30), (2, 'Bob', 25);\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "code",
                    "schema"
                  ],
                  "type": "object"
                },
                "name": "validateAndRunExoquery",
                "title": "validateAndRunExoquery"
              },
              {
                "annotations": {
                  "destructiveHint": true,
                  "idempotentHint": false,
                  "openWorldHint": true,
                  "readOnlyHint": false,
                  "title": ""
                },
                "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
                "inputSchema": {
                  "properties": {
                    "code": {
                      "description": "\nComplete ExoQuery Kotlin code to compile.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes matching your query entities\n3. The query expression using sql { ... } or sql.select { ... }\n4. A main() function ending with .buildFor.<Dialect>().runSample() or .buildPrettyFor.<Dialect>().runSample()\n   This function MUST be present to trigger SQL generation.\n\nThe runSample() function triggers SQL generation but does NOT execute the query for validateExoquery.\n(Note that this is NOT for production ExoQuery usage. For that you use `.runOn(database)`.)\n\nDialect is part of the code (e.g., .buildFor.Postgres()), NOT a separate parameter.\n\nIf compilation fails, check the error interval positions to locate the exact issue in your code.\n",
                      "type": "string"
                    }
                  },
                  "required": [
                    "code"
                  ],
                  "type": "object"
                },
                "name": "validateExoquery",
                "title": "validateExoquery"
              }
            ]
          }
        },
        "bad_protocol_status_code": 200,
        "delete_error": null,
        "delete_status_code": null,
        "expired_session_error": null,
        "expired_session_status_code": null,
        "issues": [
          "missing_session_id",
          "missing_protocol_header",
          "bad_protocol_not_rejected"
        ],
        "last_event_id_visible": false,
        "protocol_header_present": false,
        "requested_protocol_version": "2025-03-26",
        "session_id_present": false,
        "transport": "streamable-http"
      },
      "latency_ms": 43.37,
      "status": "error"
    },
    "utility_coverage_probe": {
      "details": {
        "completions": {
          "advertised": true,
          "live_probe": "not_executed",
          "sample_target": null
        },
        "initialize_capability_keys": [
          "completions",
          "prompts",
          "resources",
          "tools"
        ],
        "pagination": {
          "metadata_signal": false,
          "next_cursor_methods": [],
          "supported": false
        },
        "tasks": {
          "advertised": false,
          "http_status": 500,
          "probe_status": "missing"
        }
      },
      "latency_ms": 162.49,
      "status": "warning"
    }
  },
  "failures": {
    "openid_configuration": {
      "error": "Client error '403 Forbidden' for url 'https://backend.exoquery.com/.well-known/openid-configuration'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403",
      "url": "https://backend.exoquery.com/.well-known/openid-configuration"
    },
    "probe_noise_resilience": {
      "headers": {
        "content-type": "application/json"
      },
      "http_status": 403,
      "url": "https://backend.exoquery.com/robots.txt"
    },
    "server_card": {
      "error": "Client error '403 Forbidden' for url 'https://backend.exoquery.com/.well-known/mcp/server-card.json'\nFor more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/403",
      "url": "https://backend.exoquery.com/.well-known/mcp/server-card.json"
    },
    "transport_compliance_probe": {
      "bad_protocol_error": null,
      "bad_protocol_headers": {
        "content-type": "application/json",
        "strict-transport-security": "max-age=31536000 ; includeSubDomains"
      },
      "bad_protocol_payload": {
        "id": 410,
        "jsonrpc": "2.0",
        "result": {
          "tools": [
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "\nAccess comprehensive ExoQuery documentation organized by topic and category.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nAVAILABLE DOCUMENTATION CATEGORIES:\n\n1. **Getting Started**\n   - Introduction: What ExoQuery is and why it exists\n   - Installation: Project setup and dependencies\n   - Quick Start: First query in minutes\n\n2. **Core Concepts**\n   - SQL Blocks: The sql { } construct and query building\n   - Parameters: Safe runtime data handling\n   - Composing Queries: Functional query composition\n\n3. **Query Operations**\n   - Basic Operations: Map, filter, and transformations\n   - Joins: Inner, left, and implicit joins\n   - Grouping: GROUP BY and HAVING clauses\n   - Sorting: ORDER BY operations\n   - Subqueries: Correlated and nested queries\n   - Window Functions: Advanced analytics\n\n4. **Actions**\n   - Insert: INSERT with returning and conflict handling\n   - Update: UPDATE operations with setParams\n   - Delete: DELETE with returning\n   - Batch Operations: Bulk inserts and updates\n\n5. **Advanced Features**\n   - SQL Fragment Functions: Reusable SQL components with @SqlFragment\n   - Dynamic Queries: Runtime query generation with @SqlDynamic\n   - Free Blocks: Custom SQL and user-defined functions\n   - Transactions: Transaction support patterns\n   - Polymorphic Queries: Interfaces, sealed classes, higher-order functions\n   - Local Variables: Variables within SQL blocks\n\n6. **Data Handling**\n   - Serialization: kotlinx.serialization integration\n   - Custom Type Encoding: Custom encoders and decoders\n   - JSON Columns: JSON and JSONB support (PostgreSQL)\n   - Column Naming: @SerialName and @ExoEntity annotations\n   - Nested Datatypes: Complex data structures\n   - Kotlinx Integration: JSON and other serialization formats\n\n7. **Schema-First Development**\n   - Entity Generation: Compile-time code generation from database schema\n   - AI-Enhanced Entities: Using LLMs to generate cleaner entity code\n\n8. **Reference**\n   - SQL Functions: Available string, math, and date functions\n   - API Reference: Core types and function signatures\n\nHOW TO USE THIS RESOURCE:\n\nThe resource URI follows the pattern:\n  exoquery://docs/{file-path}\n\nWhere {file-path} is the relative path from the docs root, e.g.:\n  - exoquery://docs/01-getting-started/01-introduction.md\n  - exoquery://docs/03-query-operations/02-joins.md\n  - exoquery://docs/05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about ExoQuery syntax, features, or capabilities\n- User needs examples of specific query patterns\n- User encounters errors and needs to verify correct usage\n- User wants to understand advanced features or best practices\n",
              "inputSchema": {
                "properties": {
                  "filePath": {
                    "description": "\nThe documentation file path to retrieve.\n\nFormat: Relative path from docs root (e.g., \"01-getting-started/01-introduction.md\")\n\nThe full URI is: exoquery://docs/{file-path}\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                    "type": "string"
                  }
                },
                "required": [
                  "filePath"
                ],
                "type": "object"
              },
              "name": "getExoQueryDocs",
              "title": "getExoQueryDocs"
            },
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "\nAccess multiple ExoQuery documentation sections simultaneously.\n\nThis tool is similar to the single-document retrieval tool but allows fetching multiple documentation files in a single request. This is particularly useful when you need to gather information from several related topics at once.\n\nExoQuery is a Language Integrated Query library for Kotlin Multiplatform that translates Kotlin DSL expressions into SQL at compile time. This resource provides access to the complete documentation covering all aspects of the library.\n\nHOW TO USE THIS RESOURCE:\n\nProvide a list of file paths, where each path is the relative path from the docs root, e.g.:\n  - 01-getting-started/01-introduction.md\n  - 03-query-operations/02-joins.md\n  - 05-advanced-features/01-sql-fragments.md\n\nTo discover available documents, use the MCP resources/list endpoint which will return all available documentation files with their titles, descriptions, and categories.\n\nEach returned document includes:\n- Title and description\n- Category classification\n- Complete markdown content with code examples\n- Cross-references to related topics\n\nWHEN TO USE:\n- User asks about multiple ExoQuery topics that require information from different sections\n- User needs to compare or understand relationships between different features\n- User wants to get comprehensive information across multiple categories\n- More efficient than making multiple single-document requests\n",
              "inputSchema": {
                "properties": {
                  "filePaths": {
                    "description": "\nA list of documentation file paths to retrieve.\n\nFormat: List of relative paths from docs root (e.g., [\"01-getting-started/01-introduction.md\", \"03-query-operations/02-joins.md\"])\n\nEach path follows the pattern used in single-document retrieval: {category-folder}/{file-name}.md\n\nTo find available file paths, use the MCP resources/list endpoint which returns metadata for all documentation files including their paths, titles, categories, and descriptions.\n\nCommon paths:\n- Getting Started: 01-getting-started/01-introduction.md, 01-getting-started/02-installation.md, 01-getting-started/03-quick-start.md\n- Core Concepts: 02-core-concepts/01-sql-blocks.md, 02-core-concepts/02-parameters.md, 02-core-concepts/03-composing-queries.md\n- Query Operations: 03-query-operations/01-basic-operations.md, 03-query-operations/02-joins.md, 03-query-operations/03-grouping.md\n- Actions: 04-actions/01-insert.md, 04-actions/02-update.md, 04-actions/03-delete.md\n- Advanced: 05-advanced-features/01-sql-fragments.md, 05-advanced-features/02-dynamic-queries.md\n- Data Handling: 06-data-handling/03-json-columns.md, 06-data-handling/04-column-naming.md\n",
                    "items": {
                      "type": "string"
                    },
                    "type": "array"
                  }
                },
                "required": [
                  "filePaths"
                ],
                "type": "object"
              },
              "name": "getExoQueryDocsMulti",
              "title": "getExoQueryDocsMulti"
            },
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "Lists all available ExoQuery documentation resources with their metadata",
              "inputSchema": {
                "properties": {},
                "required": [],
                "type": "object"
              },
              "name": "listExoQueryDocs",
              "title": "listExoQueryDocs"
            },
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "\nExecute raw, client-provided SQL queries against an ephemeral database initialized with the provided schema.\nReturns query results in a simple JSON format with column headers and row data as a 2D array.\n\nThe database type (SQLite or Postgres) is specified via the databaseType parameter:\n- SQLITE: In-memory, lightweight, uses standard SQLite syntax\n- POSTGRES: Temporary isolated schema with dedicated user, uses PostgreSQL syntax and features\n\nWHEN TO USE: When you need to run your own hand-written SQL queries to test database behavior or\ncompare the output with ExoQuery results from validateAndRunExoquery. This lets you verify that\nExoQuery-generated SQL produces the same results as your expected SQL.\n\nINPUT REQUIREMENTS:\n- query: A valid SQL query (SELECT, INSERT, UPDATE, DELETE, etc.)\n- schema: SQL schema with CREATE TABLE and INSERT statements to initialize the test database\n- databaseType: Either \"SQLITE\" or \"POSTGRES\" (defaults to SQLITE if not specified)\n\nOUTPUT FORMAT:\n\nOn success, returns JSON with the SQL query and a 2D array of results:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nOutput format details:\n- First array element contains column headers\n- Subsequent array elements contain row data\n- All values are returned as strings\n\nOn error, returns JSON with error message and the attempted query (if available):\n{\"error\":\"Query execution failed: no such table: USERS\",\"sql\":\"SELECT * FROM USERS\"}\n\nOr if schema initialization fails:\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users ...\\\\n--------\",\"sql\":\"CREAT TABLE users ...\"}\n\nEXAMPLE INPUT:\n\nQuery:\nSELECT * FROM users ORDER BY id\n\nSchema:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\":\"SELECT * FROM users ORDER BY id\",\"output\":[[\"id\",\"name\",\"age\"],[\"1\",\"Alice\",\"30\"],[\"2\",\"Bob\",\"25\"],[\"3\",\"Charlie\",\"35\"]]}\n\nEXAMPLE ERROR OUTPUT (bad table name):\n{\"error\":\"Query execution failed: no such table: invalid_table\",\"sql\":\"SELECT * FROM invalid_table\"}\n\nEXAMPLE ERROR OUTPUT (bad schema):\n{\"error\":\"Database initialization failed due to: near \\\"CREAT\\\": syntax error\\\\nWhen executing the following statement:\\\\n--------\\\\nCREAT TABLE users (id INTEGER)\\\\n--------\\\\nCheck that the initialization SQL is valid and compatible with SQLite.\",\"sql\":\"CREAT TABLE users (id INTEGER)\"}\n\nCOMMON QUERY EXAMPLES:\n\nSelect all rows:\nSELECT * FROM users\n\nSelect specific columns with filtering:\nSELECT name, age FROM users WHERE age > 25\n\nAggregate functions:\nSELECT COUNT(*) as total FROM users\n\nJoin queries:\nSELECT u.name, o.total FROM users u JOIN orders o ON u.id = o.user_id\n\nInsert data:\nINSERT INTO users (name, age) VALUES ('David', 40)\n\nUpdate data:\nUPDATE users SET age = 31 WHERE name = 'Alice'\n\nDelete data:\nDELETE FROM users WHERE age < 25\n\nCount with grouping:\nSELECT age, COUNT(*) as count FROM users GROUP BY age\n\nSCHEMA RULES:\n- Use standard SQLite syntax\n- Table names are case-sensitive (use lowercase for simplicity or quote names)\n- Include INSERT statements to populate test data for meaningful results\n- Supported data types: INTEGER, TEXT, REAL, BLOB, NULL\n- Use INTEGER PRIMARY KEY for auto-increment columns\n- Schema SQL is split on semicolons (;), so each statement after a ';' is executed separately\n- Avoid semicolons in comments as they will cause statement parsing issues\n\nCOMPARISON WITH EXOQUERY:\nThis tool is designed to work alongside validateAndRunExoquery for comparison purposes:\n1. Use validateAndRunExoquery to run ExoQuery Kotlin code and see the generated SQL + results\n2. Use runRawSql with your own hand-written SQL to verify you get the same output\n3. Compare the outputs to ensure ExoQuery generates the SQL you expect\n4. Test edge cases with plain SQL before writing equivalent ExoQuery code\n",
              "inputSchema": {
                "properties": {
                  "query": {
                    "description": "\nA valid SQL query to execute against the database.\n\nCan be any valid SQL statement (syntax depends on databaseType parameter):\n- SELECT queries (with WHERE, JOIN, GROUP BY, ORDER BY, LIMIT, etc.)\n- INSERT statements\n- UPDATE statements\n- DELETE statements\n- DDL statements like CREATE/ALTER/DROP (applied after schema initialization)\n\nThe query will be executed against a database initialized with the provided schema parameter.\n\nExample:\nSELECT * FROM users WHERE age > 25 ORDER BY name\n",
                    "type": "string"
                  },
                  "schema": {
                    "description": "\nSQL schema to initialize the ephemeral test database.\n\nMust include:\n1. CREATE TABLE statements for all tables used in the query\n2. INSERT statements with test data\n\nUse syntax appropriate for the selected databaseType (SQLite or Postgres).\nTable names are case-sensitive. The schema is split on semicolons, so each statement is executed separately.\n\nExample:\nCREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT NULL,\n  age INTEGER\n);\n\nINSERT INTO users (id, name, age) VALUES (1, 'Alice', 30);\nINSERT INTO users (id, name, age) VALUES (2, 'Bob', 25);\nINSERT INTO users (id, name, age) VALUES (3, 'Charlie', 35);\n",
                    "type": "string"
                  }
                },
                "required": [
                  "query",
                  "schema"
                ],
                "type": "object"
              },
              "name": "runRawSql",
              "title": "runRawSql"
            },
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
              "inputSchema": {
                "properties": {
                  "code": {
                    "description": "\nComplete ExoQuery Kotlin code to compile and execute.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes that EXACTLY match your schema tables\n3. The query expression\n4. A main() function ending with .buildFor.<Dialect>().runSample()\n    This function MUST be present to trigger SQL generation and execution.\n\nUse @SerialName(\"column_name\") when Kotlin property names differ from SQL column names.\nUse @Contextual for BigDecimal fields.\nUse @SqlJsonValue on data classes that represent JSON column values.\n\nMultiple queries in main() will produce multiple output JSON objects.\n",
                    "type": "string"
                  },
                  "databaseType": {
                    "description": "Database type: SQLITE or POSTGRES (default: SQLITE)",
                    "type": "string"
                  },
                  "schema": {
                    "description": "\nSQL schema to initialize the Sqlite test database.\n\nMust include:\n1. CREATE TABLE statements for all tables referenced in the query\n2. INSERT statements with test data to verify query behavior\n\nTable and column names must exactly match the data classes in the code.\nUse double quotes around table names to preserve case: CREATE TABLE \"User\" (...)\n\nCommon error: Table \"USER\" not found, means you wrote CREATE TABLE User but queried \"User\".\nAlways quote table names in schema to match ExoQuery's generated SQL.\n\nExample:\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nINSERT INTO \"User\" VALUES (1, 'Alice', 30), (2, 'Bob', 25);\n",
                    "type": "string"
                  }
                },
                "required": [
                  "code",
                  "schema"
                ],
                "type": "object"
              },
              "name": "validateAndRunExoquery",
              "title": "validateAndRunExoquery"
            },
            {
              "annotations": {
                "destructiveHint": true,
                "idempotentHint": false,
                "openWorldHint": true,
                "readOnlyHint": false,
                "title": ""
              },
              "description": "\nCompile ExoQuery Kotlin code and EXECUTE it against an Sqlite database with provided schema.\nExoQuery is a compile-time SQL query builder that translates Kotlin DSL expressions into SQL.\n\nWHEN TO USE: When you need to verify ExoQuery produces correct results against actual data.\n\nINPUT REQUIREMENTS:\n- Complete Kotlin code (same requirements as validateExoquery)\n- SQL schema with CREATE TABLE and INSERT statements for test data\n- Data classes MUST exactly match the schema table structure\n- Column names in data classes must match schema (use @SerialName for snake_case columns)\n- Must include or or more .runSample() calls in main() to trigger SQL generation and execution\n  (note that .runSample() is NOT or real production use, use .runOn(database) instead)\n  \n\nOUTPUT FORMAT:\n\nReturns one or more JSON objects, each on its own line. Each object can be:\n\n1. SQL with output (query executed successfully):\n   {\"sql\": \"SELECT u.name FROM \\\"User\\\" u\", \"output\": \"[(name=Alice), (name=Bob)]\"}\n\n2. Output only (e.g., print statements, intermediate results):\n   {\"output\": \"Before: [(id=1, title=Ion Blend Beans)]\"}\n\n3. Error output (runtime errors, exceptions):\n   {\"outputErr\": \"java.sql.SQLException: Table \\\"USERS\\\" not found\"}\n\nMultiple results appear when code has multiple queries or print statements:\n\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25)]\"}\n{\"output\": \"Before:\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"Rows affected: 1\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans, unit_price=32.00, in_stock=25), (id=2, title=Luna Fuel Flask, unit_price=89.50, in_stock=6)]\"}\n\nCompilation errors return the same format as validateExoquery:\n{\n  \"errors\": {\n    \"File.kt\": [\n      {\n        \"interval\": {\"start\": {\"line\": 12, \"ch\": 10}, \"end\": {\"line\": 12, \"ch\": 15}},\n        \"message\": \"Type mismatch: inferred type is String but Int was expected\",\n        \"severity\": \"ERROR\",\n        \"className\": \"ERROR\"\n      }\n    ]\n  }\n}\n\nRuntime Errors can have the following format:\n{\n  \"errors\" : {\n    \"File.kt\" : [ ]\n  },\n  \"exception\" : {\n    \"message\" : \"[SQLITE_ERROR] SQL error or missing database (no such table: User)\",\n    \"fullName\" : \"org.sqlite.SQLiteException\",\n    \"stackTrace\" : [ {\n      \"className\" : \"org.sqlite.core.DB\",\n      \"methodName\" : \"newSQLException\",\n      \"fileName\" : \"DB.java\",\n      \"lineNumber\" : 1179\n    }, ...]\n  },\n  \"text\" : \"<outStream><outputObject>\\n{\\\"sql\\\": \\\"SELECT x.id, x.name, x.age FROM User x\\\"}\\n</outputObject>\\n</outStream>\"\n}\nIf there was a SQL query generated before the error, it will appear in the \"text\" field output stream.\n\n\nEXAMPLE INPUT CODE:\n```kotlin\nimport io.exoquery.*\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.SerialName\n\n@Serializable\ndata class User(val id: Int, val name: String, val age: Int)\n\n@Serializable\ndata class Order(val id: Int, @SerialName(\"user_id\") val userId: Int, val total: Int)\n\nval userOrders = sql.select {\n    val u = from(Table<User>())\n    val o = join(Table<Order>()) { o -> o.userId == u.id }\n    Triple(u.name, o.total, u.age)\n}\n\nfun main() = userOrders.buildPrettyFor.Sqlite().runSample()\n```\n\nEXAMPLE INPUT SCHEMA:\n```sql\nCREATE TABLE \"User\" (id INT, name VARCHAR(100), age INT);\nCREATE TABLE \"Order\" (id INT, user_id INT, total INT);\n\nINSERT INTO \"User\" (id, name, age) VALUES\n  (1, 'Alice', 30),\n  (2, 'Bob', 25);\n\nINSERT INTO \"Order\" (id, user_id, total) VALUES\n  (1, 1, 100),\n  (2, 1, 200),\n  (3, 2, 150);\n```\n\nEXAMPLE SUCCESS OUTPUT:\n{\"sql\": \"SELECT u.name AS first, o.total AS second, u.age AS third FROM \\\"User\\\" u INNER JOIN \\\"Order\\\" o ON o.user_id = u.id\", \"output\": \"[(first=Alice, second=100, third=30), (first=Alice, second=200, third=30), (first=Bob, second=150, third=25)]\"}\n\nEXAMPLE WITH MULTIPLE OPERATIONS (insert with before/after check):\n{\"output\": \"Before:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans)]\"}\n{\"sql\": \"INSERT INTO \\\"InventoryItem\\\" (title, unit_price, in_stock) VALUES (?, ?, ?)\", \"output\": \"\"}\n{\"output\": \"After:\"}\n{\"sql\": \"SELECT * FROM \\\"InventoryItem\\\"\", \"output\": \"[(id=1, title=Ion Blend Beans), (id=2, title=Luna Fuel Flask)]\"}\n\nEXAMPLE RUNTIME ERROR (if a user divided by zero):\n{\"outputErr\": \"Exception in thread \"main\" java.lang.ArithmeticException: / by zero\"}\n\nKEY PATTERNS:\n\n(See validateExoquery for complete pattern reference)\n\nSummary of most common patterns:\n- Filter: sql { Table<T>().filter { x -> x.field == value } }\n- Select: sql.select { val x = from(Table<T>()); where { ... }; x }\n- Join: sql.select { val a = from(Table<A>()); val b = join(Table<B>()) { b -> b.aId == a.id }; Pair(a, b) }\n- Left join: joinLeft(Table<T>()) { ... } returns nullable\n- Insert: sql { insert<T> { setParams(obj).excluding(id) } }\n- Update: sql { update<T>().set { it.field to value }.where { it.id == x } }\n- Delete: sql { delete<T>().where { it.id == x } }\n\nSCHEMA RULES:\n- Table names should match data class names (case-sensitive, use quotes for exact match)\n- Column names must match @SerialName values or property names\n- Include realistic test data to verify query logic\n- Sqlite database syntax (mostly compatible with standard SQL)\n\nCOMMON PATTERNS:\n- JSON columns: Use VARCHAR for storage, @SqlJsonValue on the nested data class\n- Auto-increment IDs: Use INTEGER PRIMARY KEY\n- Nullable columns: Use Type? in Kotlin, allow NULL in schema\n",
              "inputSchema": {
                "properties": {
                  "code": {
                    "description": "\nComplete ExoQuery Kotlin code to compile.\n\nMust include:\n1. Imports (minimum: io.exoquery.*, kotlinx.serialization.Serializable)\n2. @Serializable data classes matching your query entities\n3. The query expression using sql { ... } or sql.select { ... }\n4. A main() function ending with .buildFor.<Dialect>().runSample() or .buildPrettyFor.<Dialect>().runSample()\n   This function MUST be present to trigger SQL generation.\n\nThe runSample() function triggers SQL generation but does NOT execute the query for validateExoquery.\n(Note that this is NOT for production ExoQuery usage. For that you use `.runOn(database)`.)\n\nDialect is part of the code (e.g., .buildFor.Postgres()), NOT a separate parameter.\n\nIf compilation fails, check the error interval positions to locate the exact issue in your code.\n",
                    "type": "string"
                  }
                },
                "required": [
                  "code"
                ],
                "type": "object"
              },
              "name": "validateExoquery",
              "title": "validateExoquery"
            }
          ]
        }
      },
      "bad_protocol_status_code": 200,
      "delete_error": null,
      "delete_status_code": null,
      "expired_session_error": null,
      "expired_session_status_code": null,
      "issues": [
        "missing_session_id",
        "missing_protocol_header",
        "bad_protocol_not_rejected"
      ],
      "last_event_id_visible": false,
      "protocol_header_present": false,
      "requested_protocol_version": "2025-03-26",
      "session_id_present": false,
      "transport": "streamable-http"
    }
  },
  "remote_url": "https://backend.exoquery.com/mcp",
  "server_card_payload": null,
  "server_identifier": "com.exoquery/mcp-server"
}