@prostgles/app 2.3.6-dev.1788969970

package/dist/server/src/McpHub/ProstglesMcpHub/ProstglesMCPServers.d.ts

@@ -0,0 +1,4332 @@
+import type { ProstglesMcpServerHandler } from "./ProstglesMCPServerTypes";
+export declare const ProstglesMCPServers: {
+    readonly web: {
+        definition: {
+            readonly icon_path: "Web";
+            readonly label: "Web Search";
+            readonly description: "Search the web for information";
+            readonly config_schema: {
+                readonly access: {
+                    readonly renderWithComponent: "WebMcpConfig";
+                    readonly type: {
+                        readonly mode: {
+                            readonly enum: readonly ["allow", "deny", "unrestricted"];
+                            readonly description: "Access control mode. 'allow' means only URLs matching the patterns in 'hosts' are allowed. 'deny' means URLs matching the patterns are blocked. 'unrestricted' means no URL filtering or blockedSubnet check is applied.";
+                        };
+                        readonly urls: {
+                            readonly type: "string[]";
+                            readonly description: "URL Patterns can be simple substrings (e.g., 'example.com') or wildcard patterns (e.g., '*.example.com'). The 'mode' field determines whether these patterns define allowed URLs or blocked URLs.";
+                        };
+                        readonly blockInternalSubnets: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If true, the server will block requests to IP addresses in common internal subnets (e.g., localhost, private network ranges) in addition to any user-defined blocked subnets. Defaults to true.";
+                        };
+                        readonly internalSubnets: {
+                            readonly optional: true;
+                            readonly type: "string[]";
+                            readonly description: "Optional list of IP subnets in CIDR notation";
+                        };
+                    };
+                    readonly defaultValue: {
+                        readonly mode: "deny";
+                        readonly urls: readonly [];
+                        readonly blockInternalSubnets: true;
+                        readonly internalSubnets: string[];
+                    };
+                };
+            };
+            readonly tools: {
+                readonly fetch: {
+                    readonly description: "Fetches from a URL, with optional conversion for documents. DO NOT USE THIS TO FETCH WEBSITE HTML. Use the get_snapshot tool instead.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly url: {
+                                readonly type: "string";
+                                readonly description: "URL of the content to fetch";
+                            };
+                            readonly method: {
+                                readonly enum: readonly ["GET", "POST", "PUT", "DELETE", "PATCH"];
+                                readonly optional: true;
+                                readonly description: "HTTP method to use for the request. Defaults to GET.";
+                            };
+                            readonly body: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Request body for POST, PUT, or PATCH requests. Ignored for GET and DELETE requests.";
+                            };
+                            readonly mode: {
+                                readonly enum: readonly ["raw", "convert"];
+                                readonly optional: true;
+                                readonly description: "Defaults to raw. raw = fetch raw content without conversion. convert = attempt document conversion if the URL points to a document. Supported formats include txt, pdf, docx, pptx, jpg, png, and more.";
+                            };
+                            readonly headers: {
+                                readonly optional: true;
+                                readonly record: {
+                                    readonly values: "string";
+                                };
+                            };
+                            readonly start_index: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                                readonly description: "Starting index for slicing the fetched content. Defaults to 0.";
+                            };
+                            readonly max_length: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                                readonly description: "Maximum length of the returned content slice. Defaults to returning the full content.";
+                            };
+                            readonly timeout: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                                readonly description: "Maximum time in milliseconds to wait for the fetch operation. Defaults to 15000 (15 seconds).";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string";
+                    };
+                };
+                readonly websearch: {
+                    readonly description: "Performs a web search and return results. Powered by [SearXNG](https://docs.searxng.org/)";
+                    readonly schema: {
+                        readonly type: {
+                            readonly q: {
+                                readonly type: "string";
+                                readonly description: "The search query. This string is passed to external search services. Supports service-specific syntax (e.g., \"site:github.com SearXNG\" for Google)";
+                            };
+                            readonly categories: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: " Comma-separated list of active search categories. Categories to search in (e.g., 'general,images,videos')";
+                            };
+                            readonly engines: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Comma-separated list of active search engines (e.g., 'google,bing,duckduckgo')";
+                            };
+                            readonly language: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Language code for the search results (e.g., 'en' for English, 'fr' for French)";
+                            };
+                            readonly pageno: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                                readonly description: "Search result page number. Defaults to 1.";
+                            };
+                            readonly time_range: {
+                                readonly enum: readonly ["day", "month", "year"];
+                                readonly optional: true;
+                                readonly description: "Time range filter for results ('day' = past day, 'month' = past month, 'year' = past year). Only supported by engines that implement time range filtering";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOfType: {
+                            readonly title: "string";
+                            readonly content: "string";
+                            readonly url: "string";
+                            readonly score: "number";
+                            readonly category: "string";
+                            readonly engine: "string";
+                            readonly img_src: "string";
+                            readonly thumbnail: "any";
+                            readonly template: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly publishedDate: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly parsed_url: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly priority: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly engines: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly positions: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                            readonly pubdate: {
+                                readonly optional: true;
+                                readonly type: "any";
+                            };
+                        };
+                    };
+                };
+                readonly get_snapshot: {
+                    readonly description: "Get a snapshot of a web page";
+                    readonly schema: {
+                        readonly type: {
+                            readonly url: {
+                                readonly type: "string";
+                                readonly description: "URL of the web page to snapshot";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string";
+                    };
+                };
+                readonly get_document_text: {
+                    readonly description: "Get text contents of a document";
+                    readonly schema: {
+                        readonly type: {
+                            readonly url: {
+                                readonly type: "string";
+                            };
+                            readonly from_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                            };
+                            readonly image_export_mode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                                readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                            };
+                            readonly page_range: {
+                                readonly tuple: readonly ["number", "number"];
+                                readonly optional: true;
+                                readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                            };
+                            readonly do_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                            };
+                            readonly force_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                            };
+                            readonly ocr_engine: {
+                                readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                                readonly optional: true;
+                                readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                            };
+                            readonly ocr_lang: {
+                                readonly type: "string[]";
+                                readonly optional: true;
+                                readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                            };
+                            readonly document_timeout: {
+                                readonly optional: true;
+                                readonly type: "number";
+                                readonly description: "The timeout for processing each document, in seconds.";
+                            };
+                            readonly pdf_backend: {
+                                readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                                readonly optional: true;
+                                readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                            };
+                            readonly table_mode: {
+                                readonly enum: readonly ["fast", "accurate"];
+                                readonly optional: true;
+                                readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                            };
+                            readonly do_table_structure: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                            };
+                            readonly include_images: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                            };
+                            readonly md_page_break_placeholder: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Add this placeholder between pages in the markdown output.";
+                            };
+                            readonly images_scale: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        handler: ProstglesMcpServerHandler;
+    };
+    readonly webdev: {
+        definition: {
+            readonly icon_path: "React";
+            readonly label: "Web Dev Environment";
+            readonly description: "React vite based web development environment.";
+            readonly config_schema: undefined;
+            readonly tools: {
+                readonly list_directory: {
+                    readonly description: "List files in the web app directory. Will truncate long lists.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly directoryPath: {
+                                readonly type: "string";
+                                readonly description: "Directory path to list files from the web app directory. Example: 'src/components'";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOf: "string";
+                    };
+                };
+                readonly read_files: {
+                    readonly description: "Read files from the web app directory";
+                    readonly schema: {
+                        readonly type: {
+                            readonly filePaths: {
+                                readonly description: "File paths to read from the web app directory.";
+                                readonly arrayOf: "string";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOfType: {
+                            readonly filePath: "string";
+                            readonly content: "string";
+                        };
+                    };
+                };
+                readonly search_files: {
+                    readonly description: "Search files by content and/or file name in the web app directory";
+                    readonly schema: {
+                        readonly type: {
+                            readonly contentQuery: {
+                                readonly type: "string";
+                                readonly description: "File content search query. Example: 'useState' to search for files that include 'useState'";
+                                readonly optional: true;
+                            };
+                            readonly fileNameQuery: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "File name search query to further filter search results. Example: 'Counter' to only include files with 'Counter' in the file name.";
+                            };
+                            readonly extensions: {
+                                readonly description: "File extensions to limit the search to (e.g., ['ts', 'tsx', 'js', 'jsx'])";
+                                readonly arrayOf: "string";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOfType: {
+                            readonly filePath: "string";
+                            readonly matchedContent: "string";
+                        };
+                    };
+                };
+                readonly create_component_quick_feedback_preview: {
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly indexTsx: {
+                                readonly type: "string";
+                                readonly description: "tsx code for the component. Example: 'import { useState } from \"react\"; ...'";
+                            };
+                            readonly css: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "css code for the component. Example: '.container { display: flex; }'";
+                            };
+                            readonly dependencies: {
+                                readonly description: "Dependencies to install in the environment (e.g., react, axios)";
+                                readonly arrayOf: "string";
+                                readonly optional: true;
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "unknown";
+                    };
+                };
+                readonly create_component: {
+                    readonly description: "Create a react component";
+                    readonly schema: {
+                        readonly type: {
+                            readonly entryPoint: {
+                                readonly type: "string";
+                                readonly description: "Entry point file for the component. Example: '@/components/Counter/Counter.tsx'";
+                            };
+                            readonly files: {
+                                readonly description: "tsx/css and other files for the component. Example: { \"@/components/Counter/Counter.tsx\":  \"import { useState } from \"react\"; ...\"  } ";
+                                readonly record: {
+                                    readonly values: "string";
+                                };
+                            };
+                            readonly dependencies: {
+                                readonly description: "Dependencies to install in the environment (e.g., react, axios)";
+                                readonly arrayOf: "string";
+                                readonly optional: true;
+                            };
+                            readonly devDependencies: {
+                                readonly description: "Dev Dependencies to install in the environment (e.g., @types/pkg)";
+                                readonly arrayOf: "string";
+                                readonly optional: true;
+                            };
+                            readonly test: {
+                                readonly description: "Playwright test to run against the component. Example:  'import { test, expect } from \"@playwright/react\"; ...'";
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "unknown";
+                    };
+                };
+            };
+        };
+        handler: ProstglesMcpServerHandler;
+    };
+    readonly "prostgles-ui": {
+        definition: {
+            readonly icon_path: "CubeOutline";
+            readonly label: "Prostgles";
+            readonly description: "Tools to assist with Prostgles UI tasks";
+            readonly config_schema: undefined;
+            readonly tools: {
+                readonly compact_context: {
+                    readonly icon: "ArrowCollapse";
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly type: {
+                                readonly enum: readonly ["conversation", "previous-message"];
+                            };
+                            readonly summary: {
+                                readonly type: "string";
+                                readonly description: "When type=conversation it is a summary of the conversation so far. When type=previous-message it is a summary of the previous message.";
+                            };
+                        };
+                    };
+                    readonly outputSchema: "string";
+                };
+                readonly run_code_in_sandbox: {
+                    readonly icon: "Docker";
+                    readonly annotations: {
+                        readonly openWorldHint: true;
+                    };
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Reason for executing the code to provide context to the user. One short sentence is enough. ";
+                            };
+                            readonly files: {
+                                readonly description: string;
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly type: "string";
+                                        readonly description: "File content. E.g.: 'import type { JSONB } from \"prostgles-types\";' ";
+                                    };
+                                };
+                            };
+                            readonly userInputValue: {
+                                readonly optional: true;
+                                readonly description: "User populated values for the userInput keys. It will override the default values in userInput if provided. ";
+                                readonly record: {
+                                    readonly values: "unknown";
+                                };
+                            };
+                            readonly timeout: {
+                                readonly optional: true;
+                                readonly type: "integer";
+                                readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                            };
+                            readonly networkMode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["none", "bridge", "bridge-internal", "host"];
+                                readonly description: "Network mode for the container. Defaults to 'bridge-internal'. Use 'bridge' mode to be able to access the database. Use 'bridge-internal' to access the database but not the internet.";
+                            };
+                            readonly environment: {
+                                readonly optional: true;
+                                readonly description: "Environment variables to set in the container";
+                                readonly record: {
+                                    readonly values: "string";
+                                    readonly partial: true;
+                                };
+                            };
+                            readonly memory: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                            };
+                            readonly cpus: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                            };
+                            readonly readOnly: {
+                                readonly optional: true;
+                                readonly type: "boolean";
+                                readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                            };
+                            readonly userInput: {
+                                readonly description: string;
+                                readonly optional: true;
+                                readonly record: {
+                                    readonly values: {
+                                        readonly oneOfType: readonly [{
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-column-value"];
+                                            };
+                                            readonly tableName: "string";
+                                            readonly columnName: "string";
+                                            readonly defaultValue: {
+                                                readonly type: "any";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-column-values"];
+                                            };
+                                            readonly tableName: "string";
+                                            readonly columnName: "string";
+                                            readonly defaultValue: {
+                                                readonly type: "any[]";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-filter"];
+                                            };
+                                            readonly tableName: "string";
+                                            readonly defaultValue: {
+                                                readonly record: {
+                                                    readonly values: "any";
+                                                };
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-column"];
+                                            };
+                                            readonly tableName: "string";
+                                            readonly defaultValue: {
+                                                readonly type: "string";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-name"];
+                                            };
+                                            readonly defaultValue: {
+                                                readonly type: "string";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["table-and-column"];
+                                            };
+                                            readonly defaultValue: {
+                                                readonly type: {
+                                                    readonly tableName: "string";
+                                                    readonly columnName: "string";
+                                                };
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["enum"];
+                                            };
+                                            readonly values: "string[]";
+                                            readonly defaultValue: {
+                                                readonly type: "string";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["custom"];
+                                            };
+                                            readonly dataType: {
+                                                readonly enum: readonly ["string", "number", "boolean", "Date"];
+                                            };
+                                            readonly defaultValue: {
+                                                readonly type: "unknown";
+                                                readonly optional: true;
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["folder-path", "file-path", "file-or-folder-path"];
+                                            };
+                                            readonly accessMode: {
+                                                readonly enum: readonly ["read", "read-write"];
+                                            };
+                                        }, {
+                                            readonly title: "string";
+                                            readonly optional: {
+                                                readonly type: "boolean";
+                                                readonly optional: true;
+                                            };
+                                            readonly type: {
+                                                readonly enum: readonly ["folder-paths", "file-paths", "file-or-folder-paths"];
+                                            };
+                                            readonly accessMode: {
+                                                readonly enum: readonly ["read", "read-write"];
+                                            };
+                                        }];
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: {
+                            readonly state: {
+                                readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+                            };
+                            readonly name: "string";
+                            readonly command: "string";
+                            readonly log: {
+                                readonly arrayOfType: {
+                                    readonly type: {
+                                        readonly enum: readonly ["stdout", "stderr", "error"];
+                                    };
+                                    readonly text: "string";
+                                };
+                            };
+                            readonly exitCode: "number";
+                            readonly runDuration: "number";
+                            readonly buildDuration: "number";
+                        };
+                    };
+                };
+                readonly run_typescript_in_nodejs: {
+                    readonly icon: "Nodejs";
+                    readonly annotations: {
+                        readonly openWorldHint: true;
+                    };
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Reason for executing the code to provide context to the user. One short sentence is enough. ";
+                            };
+                            readonly timeout: {
+                                readonly optional: true;
+                                readonly type: "integer";
+                                readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                            };
+                            readonly networkMode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["none", "bridge", "bridge-internal", "host"];
+                                readonly description: "Network mode for the container. Defaults to 'bridge-internal'. Use 'bridge' mode to be able to access the database. Use 'bridge-internal' to access the database but not the internet.";
+                            };
+                            readonly environment: {
+                                readonly optional: true;
+                                readonly description: "Environment variables to set in the container";
+                                readonly record: {
+                                    readonly values: "string";
+                                    readonly partial: true;
+                                };
+                            };
+                            readonly memory: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                            };
+                            readonly cpus: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                            };
+                            readonly readOnly: {
+                                readonly optional: true;
+                                readonly type: "boolean";
+                                readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                            };
+                            readonly entrypointTs: {
+                                readonly type: "string";
+                                readonly description: "Typescript code to execute. Must compile with no errors assuming strict tsconfig and recommended eslint rules.";
+                            };
+                            readonly packageDependencies: {
+                                readonly optional: true;
+                                readonly description: "Dependencies to install in the container. Must be reputable npm packages. Example: { \"prostgles-types\": \"^4.0.217\" }";
+                                readonly record: {
+                                    readonly values: "string";
+                                };
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: {
+                            readonly state: {
+                                readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+                            };
+                            readonly name: "string";
+                            readonly command: "string";
+                            readonly log: {
+                                readonly arrayOfType: {
+                                    readonly type: {
+                                        readonly enum: readonly ["stdout", "stderr", "error"];
+                                    };
+                                    readonly text: "string";
+                                };
+                            };
+                            readonly exitCode: "number";
+                            readonly runDuration: "number";
+                            readonly buildDuration: "number";
+                        };
+                    };
+                };
+                readonly ask_user_questions: {
+                    readonly icon: "AccountQuestionOutline";
+                    readonly mode: "user-provides-response";
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly questions: {
+                                readonly arrayOf: {
+                                    readonly oneOfType: readonly [{
+                                        readonly type: {
+                                            readonly enum: readonly ["choice"];
+                                        };
+                                        readonly question: {
+                                            readonly type: "string";
+                                            readonly description: "The question to ask the user";
+                                        };
+                                        readonly allowMultipleChoices: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                            readonly description: "If true, the user can select multiple choices. Defaults to false.";
+                                        };
+                                        readonly suggestedAnswers: {
+                                            readonly description: "The list of suggested answers the user will choose from";
+                                            readonly arrayOf: "string";
+                                        };
+                                    }, {
+                                        readonly type: {
+                                            readonly enum: readonly ["free-text"];
+                                        };
+                                        readonly question: {
+                                            readonly type: "string";
+                                            readonly description: "The question to ask the user";
+                                        };
+                                    }, {
+                                        readonly type: {
+                                            readonly enum: readonly ["table-name"];
+                                        };
+                                        readonly question: {
+                                            readonly type: "string";
+                                            readonly description: "The question to ask the user";
+                                        };
+                                        readonly suggestedTableName: {
+                                            readonly type: "string";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly type: {
+                                            readonly enum: readonly ["table-columns"];
+                                        };
+                                        readonly tableName: "string";
+                                        readonly question: {
+                                            readonly type: "string";
+                                            readonly description: "The question to ask the user";
+                                        };
+                                        readonly suggestedColumns: {
+                                            readonly type: "string[]";
+                                            readonly optional: true;
+                                        };
+                                    }];
+                                };
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOfType: {
+                            readonly question: "string";
+                            readonly answers: "string[]";
+                        };
+                    };
+                };
+                readonly get_tool_list: {
+                    readonly icon: "Tools";
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {};
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOfType: {
+                            readonly server_name: "string";
+                            readonly tool_name: "string";
+                        };
+                    };
+                };
+                readonly get_specific_tool_schemas: {
+                    readonly icon: "Tools";
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly mcpServerTools: {
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly enum: readonly [1];
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly description: string;
+                            };
+                            readonly infoLevel: {
+                                readonly optional: true;
+                                readonly enum: readonly ["full", "basic"];
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly record: {
+                            readonly values: {
+                                readonly record: {
+                                    readonly values: {
+                                        readonly type: {
+                                            readonly description: "string";
+                                            readonly tsDefinition: "string";
+                                            readonly inputSchema: {
+                                                readonly record: {
+                                                    readonly values: "unknown";
+                                                };
+                                            };
+                                            readonly outputSchema: {
+                                                readonly nullable: true;
+                                                readonly record: {
+                                                    readonly values: "unknown";
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly request_tool_access: {
+                    readonly icon: "LockQuestion";
+                    readonly mode: "auto-approved-user-actionable";
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly reason: {
+                                readonly description: "Reason for requesting access to the tool";
+                                readonly type: "string";
+                                readonly optional: true;
+                            };
+                            readonly mcpServerTools: {
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly enum: readonly [1];
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly description: "List of MCP server tools to enable for this chat. Example: { web: { fetch: 1 } }";
+                                readonly optional: true;
+                            };
+                            readonly databaseAccess: {
+                                readonly optional: true;
+                                readonly description: "Database access configuration. Use the most restrictive access type that is needed to complete the task.";
+                                readonly oneOfType: readonly [{
+                                    readonly mode: {
+                                        readonly enum: readonly ["execute_readonly_sql"];
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["execute_sql"];
+                                    };
+                                    readonly allowedCommands: {
+                                        readonly optional: true;
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly keysEnum: readonly ["select", "insert", "update", "delete"];
+                                            readonly values: {
+                                                readonly enum: readonly [1];
+                                            };
+                                        };
+                                    };
+                                }, {
+                                    readonly mode: {
+                                        readonly enum: readonly ["custom"];
+                                    };
+                                    readonly tablePermissions: {
+                                        readonly title: "Tables";
+                                        readonly description: "Tables the assistant can access";
+                                        readonly record: {
+                                            readonly values: {
+                                                readonly type: {
+                                                    readonly select: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly enum: readonly [true];
+                                                        }, {
+                                                            readonly type: {
+                                                                readonly forcedFilter: {
+                                                                    readonly optional: true;
+                                                                    readonly oneOfType: readonly [{
+                                                                        readonly $and: "any[]";
+                                                                    }, {
+                                                                        readonly $or: "any[]";
+                                                                    }];
+                                                                };
+                                                                readonly fields: {
+                                                                    readonly oneOf: readonly [{
+                                                                        readonly enum: readonly ["*"];
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [1];
+                                                                            };
+                                                                        };
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [0];
+                                                                            };
+                                                                        };
+                                                                    }];
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly optional: true;
+                                                    };
+                                                    readonly update: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly enum: readonly [true];
+                                                        }, {
+                                                            readonly type: {
+                                                                readonly forcedFilter: {
+                                                                    readonly optional: true;
+                                                                    readonly oneOfType: readonly [{
+                                                                        readonly $and: "any[]";
+                                                                    }, {
+                                                                        readonly $or: "any[]";
+                                                                    }];
+                                                                };
+                                                                readonly fields: {
+                                                                    readonly oneOf: readonly [{
+                                                                        readonly enum: readonly ["*"];
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [1];
+                                                                            };
+                                                                        };
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [0];
+                                                                            };
+                                                                        };
+                                                                    }];
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly optional: true;
+                                                    };
+                                                    readonly insert: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly enum: readonly [true];
+                                                        }, {
+                                                            readonly type: {
+                                                                readonly fields: {
+                                                                    readonly oneOf: readonly [{
+                                                                        readonly enum: readonly ["*"];
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [1];
+                                                                            };
+                                                                        };
+                                                                    }, {
+                                                                        readonly record: {
+                                                                            readonly values: {
+                                                                                readonly enum: readonly [0];
+                                                                            };
+                                                                        };
+                                                                    }];
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly optional: true;
+                                                    };
+                                                    readonly delete: {
+                                                        readonly oneOf: readonly [{
+                                                            readonly enum: readonly [true];
+                                                        }, {
+                                                            readonly type: {
+                                                                readonly forcedFilter: {
+                                                                    readonly optional: true;
+                                                                    readonly oneOfType: readonly [{
+                                                                        readonly $and: "any[]";
+                                                                    }, {
+                                                                        readonly $or: "any[]";
+                                                                    }];
+                                                                };
+                                                            };
+                                                        }];
+                                                        readonly optional: true;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: {
+                            readonly validatedTools: {
+                                readonly arrayOfType: {
+                                    readonly id: "number";
+                                    readonly server_name: "string";
+                                    readonly config_id: {
+                                        readonly oneOf: readonly ["number", {
+                                            readonly enum: readonly [null];
+                                        }];
+                                    };
+                                };
+                            };
+                            readonly status: {
+                                readonly optional: true;
+                                readonly enum: readonly ["approved", "denied"];
+                            };
+                        };
+                    };
+                };
+                readonly create_tables: {
+                    readonly icon: "TablePlus";
+                    readonly mode: undefined;
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly ddlStatements: {
+                                readonly description: "SQL DDL statements to create tables. Only CREATE TABLE, CREATE VIEW and CREATE INDEX statements are allowed.";
+                                readonly type: "string";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: {
+                            readonly data: "unknown[]";
+                        };
+                    };
+                };
+                readonly create_agent: {
+                    readonly icon: "RobotOutline";
+                    readonly mode: "always-needs-approval";
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly tools: {
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly record: {
+                                            readonly partial: true;
+                                            readonly values: {
+                                                readonly enum: readonly [1];
+                                            };
+                                        };
+                                    };
+                                };
+                                readonly description: "List of MCP server tools available to the agent. Example: { web: { fetch: 1 } }";
+                                readonly optional: true;
+                            };
+                            readonly firstMessage: {
+                                readonly description: "The first message to send to the agent. If not provided, the agent will start with an empty message.";
+                                readonly optional: true;
+                                readonly type: "string";
+                            };
+                            readonly prompt: {
+                                readonly type: "string";
+                            };
+                            readonly modelName: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "The name of the LLM model to use for this agent. If not provided, the default model will be used.";
+                            };
+                            readonly maxCostUSD: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "The maximum cost in USD that this agent is allowed to incur.";
+                            };
+                            readonly maxIterations: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "The maximum number of iterations this agent is allowed to run.";
+                            };
+                            readonly mcpServerConfigs: {
+                                readonly optional: true;
+                                readonly description: "SYSTEM ONLY — DO NOT SPECIFY: Do not generate, invent, or prompt the user for configuration IDs. This field is automatically injected by the host runtime when a tool requires user-provided MCP server authorization.";
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly type: {
+                                            readonly configId: {
+                                                readonly type: "number";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                            readonly maxTokens: {
+                                readonly type: "number";
+                                readonly optional: true;
+                            };
+                            readonly temperature: {
+                                readonly type: "number";
+                                readonly optional: true;
+                            };
+                            readonly name: "string";
+                            readonly autoApproveAllTools: "boolean";
+                            readonly timeout: "integer";
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly oneOfType: readonly [{
+                            readonly success: {
+                                readonly enum: readonly [true];
+                            };
+                            readonly result: "string";
+                        }, {
+                            readonly success: {
+                                readonly enum: readonly [false];
+                            };
+                            readonly error: "string";
+                        }];
+                    };
+                };
+                readonly create_agentic_workflow: {
+                    readonly icon: "CubeOutline";
+                    readonly mode: "auto-approved-user-actionable";
+                    readonly description: "Creates an agentic workflow which is executed manually by the user to iteratively complete the specified task using MCP tools and database access if needed. Runtime logs are only visible to the user. Definition validation is not a substitute for testing external runtime assumptions";
+                    readonly schema: {
+                        readonly type: {
+                            readonly workflow_function_definition: {
+                                readonly type: "string";
+                                readonly description: "Typescript code defining a function that returns an agent workflow. The function must satisfy the following type provided. The function can use available MCP tools and database access if needed. Available MCP tools and database access are determined by the fetchTools function and the input to this tool.";
+                            };
+                            readonly workflow_function_definition_summary: {
+                                readonly type: "string";
+                                readonly description: "A concise summary of the workflow function definition for the user to understand what the workflow does without having to read the code. This will be shown to the user when asking for approval to run the workflow.";
+                            };
+                            readonly package_dependencies: {
+                                readonly optional: true;
+                                readonly description: "A list of npm packages to be added to the container package.json dependencies.";
+                                readonly record: {
+                                    readonly values: "string";
+                                };
+                            };
+                            readonly workflowId: {
+                                readonly type: "integer";
+                                readonly optional: true;
+                                readonly description: "FOR INTERNAL USE ONLY. DO NOT ASK USER ABOUT THIS. Workflow ID to update instead of creating a new workflow. If not provided, a new workflow will be created.";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly oneOfType: readonly [{
+                            readonly isValid: {
+                                readonly enum: readonly [true];
+                            };
+                            readonly workflowId: "number";
+                        }, {
+                            readonly isValid: {
+                                readonly enum: readonly [false];
+                            };
+                            readonly logs: "string";
+                            readonly error: {
+                                readonly type: "unknown";
+                                readonly optional: true;
+                            };
+                        }];
+                    };
+                };
+                readonly get_tables_metadata: {
+                    readonly icon: "Table";
+                    readonly mode: undefined;
+                    readonly description: "Get rendering metadata for database tables.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableNames: "string[]";
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "unknown";
+                    };
+                };
+                readonly set_tables_metadata: {
+                    readonly icon: "Table";
+                    readonly mode: undefined;
+                    readonly description: "Set rendering metadata for database tables";
+                    readonly schema: {
+                        readonly type: {
+                            readonly metadata: {
+                                readonly record: {
+                                    readonly partial: true;
+                                    readonly values: {
+                                        readonly type: {
+                                            readonly icon: {
+                                                readonly type: "string";
+                                                readonly description: "MDI Icon name. For example: 'AccessPointNetwork', 'Github'";
+                                                readonly optional: true;
+                                            };
+                                            readonly label: {
+                                                readonly type: "string";
+                                                readonly optional: true;
+                                            };
+                                            readonly sort: {
+                                                readonly optional: true;
+                                                readonly description: "Default sort order for new table views";
+                                                readonly arrayOfType: {
+                                                    readonly key: "string";
+                                                    readonly asc: "boolean";
+                                                    readonly nulls: {
+                                                        readonly enum: readonly ["first", "last"];
+                                                        readonly optional: true;
+                                                    };
+                                                };
+                                            };
+                                            readonly rowIconColumn: {
+                                                readonly type: "string";
+                                                readonly description: "Column name that contains url to a local icon (in /icons folder) to be shown as an icon in each row. This is used in card and table views.";
+                                                readonly optional: true;
+                                            };
+                                            readonly columns: {
+                                                readonly optional: true;
+                                                readonly record: {
+                                                    readonly partial: true;
+                                                    readonly values: {
+                                                        readonly type: {
+                                                            readonly icon: {
+                                                                readonly type: "string";
+                                                                readonly optional: true;
+                                                            };
+                                                            readonly renderAs: {
+                                                                readonly optional: true;
+                                                                readonly title: "Display format";
+                                                                readonly description: "Control how data is displayed";
+                                                                readonly oneOfType: readonly [{
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["NONE"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display data as is. Default";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["URL"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Clickable URL";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Email"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Email link";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Tel"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Telephone number link";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["QR Code"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display a URL as an image";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly title: "Format";
+                                                                        readonly enum: readonly ["Currency"];
+                                                                        readonly description: "With currency symbol";
+                                                                    };
+                                                                    readonly params: {
+                                                                        readonly oneOfType: readonly [{
+                                                                            readonly mode: {
+                                                                                readonly enum: readonly ["Fixed"];
+                                                                                readonly title: "Type";
+                                                                            };
+                                                                            readonly metricPrefix: {
+                                                                                readonly type: "boolean";
+                                                                                readonly title: "Use Metric Prefix";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly currencyCode: {
+                                                                                readonly type: "string";
+                                                                                readonly title: "Currency code";
+                                                                                readonly description: "EUR, GBP, USD, etc...";
+                                                                            };
+                                                                        }, {
+                                                                            readonly mode: {
+                                                                                readonly enum: readonly ["From column"];
+                                                                                readonly title: "Type";
+                                                                            };
+                                                                            readonly metricPrefix: {
+                                                                                readonly type: "boolean";
+                                                                                readonly title: "Use Metric Prefix";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly currencyCodeField: {
+                                                                                readonly type: "string";
+                                                                                readonly title: "Currency Field";
+                                                                                readonly description: "Column containing the currency code (EUR, GBP, USD, etc...)";
+                                                                            };
+                                                                        }];
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Metric Prefix"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display large numbers with metric prefixes (e.g. 1.2K)";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["UNIX Timestamp"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display unix timestamp as datetime";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Age"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display time difference between now and the value";
+                                                                    };
+                                                                    readonly params: {
+                                                                        readonly optional: true;
+                                                                        readonly type: {
+                                                                            readonly variant: {
+                                                                                readonly title: "Variant";
+                                                                                readonly description: "Short shows top two biggest units";
+                                                                                readonly enum: readonly ["short", "full"];
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Markdown", "MarkdownPopup"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display string as Markdown";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["JSON Diff", "Text Diff"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Compare JSON or plain text values from two columns";
+                                                                    };
+                                                                    readonly params: {
+                                                                        readonly type: {
+                                                                            readonly oldColumn: "string";
+                                                                            readonly newColumn: "string";
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["DoclingDocument"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Renders a Docling parsed document";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Logs"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Renders a log viewer for text data";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["HTML"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display string as sanitised HTML";
+                                                                    };
+                                                                    readonly params: {
+                                                                        readonly type: {
+                                                                            readonly noSanitize: {
+                                                                                readonly type: "boolean";
+                                                                                readonly title: "Do not sanitize HTML";
+                                                                                readonly description: "Leave unchecked if you understand the risks";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly allowedHTMLTags: {
+                                                                                readonly title: "Allowed HTML Tags";
+                                                                                readonly type: "string[]";
+                                                                                readonly allowedValues: string[];
+                                                                                readonly description: "List of allowed HTML tags. E.g.: div, p, html";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Media"];
+                                                                        readonly title: "Format";
+                                                                        readonly description: "Display media (video/image/audio) from URL";
+                                                                    };
+                                                                    readonly params: {
+                                                                        readonly type: {
+                                                                            readonly contentType: {
+                                                                                readonly optional: true;
+                                                                                readonly title: "Content type";
+                                                                                readonly oneOfType: readonly [{
+                                                                                    readonly mode: {
+                                                                                        readonly enum: readonly ["Auto"];
+                                                                                        readonly title: "Auto detect from URL and headers (default)";
+                                                                                    };
+                                                                                }, {
+                                                                                    readonly mode: {
+                                                                                        readonly enum: readonly ["Fixed"];
+                                                                                        readonly title: "Fixed";
+                                                                                    };
+                                                                                    readonly fixedContentType: {
+                                                                                        readonly type: "string";
+                                                                                        readonly title: "Fixed content type";
+                                                                                        readonly allowedValues: readonly ["image", "video", "audio"];
+                                                                                    };
+                                                                                }, {
+                                                                                    readonly mode: {
+                                                                                        readonly enum: readonly ["From column"];
+                                                                                        readonly title: "From column";
+                                                                                    };
+                                                                                    readonly contentTypeColumnName: {
+                                                                                        readonly title: "MIME column";
+                                                                                        readonly type: "string";
+                                                                                        readonly description: "Column that contains valid extension values (img, mp4, mp3, ...)";
+                                                                                    };
+                                                                                }, {
+                                                                                    readonly mode: {
+                                                                                        readonly enum: readonly ["From URL Extension"];
+                                                                                        readonly title: "From URL Extension (e.g. .png, .mp4)";
+                                                                                    };
+                                                                                }];
+                                                                            };
+                                                                            readonly titleColumn: {
+                                                                                readonly optional: true;
+                                                                                readonly type: "string";
+                                                                                readonly title: "Title column";
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                }];
+                                                            };
+                                                            readonly style: {
+                                                                readonly optional: true;
+                                                                readonly oneOf: readonly [{
+                                                                    readonly type: {
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["Conditional"];
+                                                                        };
+                                                                        readonly column: {
+                                                                            readonly type: "string";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly conditions: {
+                                                                            readonly arrayOf: {
+                                                                                readonly oneOf: readonly [{
+                                                                                    readonly type: {
+                                                                                        readonly textColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly chipColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly cellColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly borderColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly operator: {
+                                                                                            readonly enum: readonly ["contains", "=", ">", ">=", "<", "<=", "!="];
+                                                                                        };
+                                                                                        readonly condition: "any";
+                                                                                    };
+                                                                                }, {
+                                                                                    readonly type: {
+                                                                                        readonly textColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly chipColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly cellColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly borderColor: {
+                                                                                            readonly type: "string";
+                                                                                            readonly optional: true;
+                                                                                        };
+                                                                                        readonly operator: {
+                                                                                            readonly enum: readonly ["in", "not in"];
+                                                                                        };
+                                                                                        readonly condition: "any[]";
+                                                                                    };
+                                                                                }];
+                                                                            };
+                                                                        };
+                                                                        readonly defaultStyle: {
+                                                                            readonly optional: true;
+                                                                            readonly type: {
+                                                                                readonly textColor: {
+                                                                                    readonly type: "string";
+                                                                                    readonly optional: true;
+                                                                                };
+                                                                                readonly chipColor: {
+                                                                                    readonly type: "string";
+                                                                                    readonly optional: true;
+                                                                                };
+                                                                                readonly cellColor: {
+                                                                                    readonly type: "string";
+                                                                                    readonly optional: true;
+                                                                                };
+                                                                                readonly borderColor: {
+                                                                                    readonly type: "string";
+                                                                                    readonly optional: true;
+                                                                                };
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["Scale"];
+                                                                        };
+                                                                        readonly textColor: "string";
+                                                                        readonly minColor: "string";
+                                                                        readonly maxColor: "string";
+                                                                    };
+                                                                }, {
+                                                                    readonly type: {
+                                                                        readonly type: {
+                                                                            readonly enum: readonly ["Barchart"];
+                                                                        };
+                                                                        readonly barColor: "string";
+                                                                        readonly textColor: "string";
+                                                                    };
+                                                                }];
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                            readonly card: {
+                                                readonly optional: true;
+                                                readonly description: "Card view options";
+                                                readonly type: {
+                                                    readonly avatarColumn: {
+                                                        readonly type: "string";
+                                                        readonly description: "Column name that contains url to an image to be shown as an avatar in card view.";
+                                                        readonly optional: true;
+                                                    };
+                                                    readonly headerColumn: {
+                                                        readonly optional: true;
+                                                        readonly type: "string";
+                                                        readonly description: "Column name that should be used as the header in card view.";
+                                                    };
+                                                    readonly subHeaderColumn: {
+                                                        readonly optional: true;
+                                                        readonly type: "string";
+                                                        readonly description: "Column name that should be used as the sub-header in card view.";
+                                                    };
+                                                    readonly visibleColumns: {
+                                                        readonly optional: true;
+                                                        readonly description: "Array of column names that should be visible in card view by default";
+                                                        readonly arrayOf: {
+                                                            readonly oneOf: readonly ["string", {
+                                                                readonly type: {
+                                                                    readonly column: "string";
+                                                                    readonly hideLabel: {
+                                                                        readonly type: "boolean";
+                                                                        readonly optional: true;
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "unknown";
+                    };
+                };
+                readonly find_icons: {
+                    readonly icon: "ImageSearch";
+                    readonly mode: undefined;
+                    readonly description: "Search for icons by name. Returns a list of icon names that match the search query.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly query: "string";
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string[]";
+                    };
+                };
+                readonly create_dashboards: {
+                    readonly icon: "ViewCarousel";
+                    readonly mode: "auto-approved-user-actionable";
+                    readonly description: "Suggest Prostgles UI dashboards to visualize data for the specified task.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly prostglesWorkspaces: {
+                                readonly description: "Workspace to create. Must satisfy the typescript WorkspaceInsertModel type";
+                                readonly arrayOf: "any";
+                            };
+                        };
+                    };
+                    readonly outputSchema: "string";
+                };
+            };
+        };
+        handler: ProstglesMcpServerHandler;
+    };
+    readonly db: {
+        definition: {
+            readonly icon_path: "DatabaseOutline";
+            readonly label: "Database";
+            readonly description: "Tools to interact with your database";
+            readonly tools: {
+                readonly get_existing_tables_schema: {
+                    readonly icon: "DatabaseEyeOutline";
+                    readonly description: string;
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableNames: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                            };
+                            readonly tableNameRegex: {
+                                readonly optional: true;
+                                readonly type: "string";
+                                readonly description: "Regular expression to match table names. For example, 'user' will match tables with names like 'user', 'users', 'app_user', etc.";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string";
+                    };
+                };
+                readonly execute_readonly_sql: {
+                    readonly icon: "DatabaseSearchOutline";
+                    readonly annotations: {
+                        readonly readOnlyHint: true;
+                    };
+                    readonly description: "Executes a SQL query on the connected database in readonly mode (no data can be changed, the transaction is rolled back at the end).";
+                    readonly schema: {
+                        readonly type: {
+                            readonly sql: {
+                                readonly type: "string";
+                                readonly description: "SQL query to execute";
+                            };
+                            readonly query_timeout: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                            };
+                            readonly query_params: {
+                                readonly optional: true;
+                                readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                                readonly oneOf: readonly ["any[]", {
+                                    readonly record: {
+                                        readonly values: "any";
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    };
+                };
+                readonly execute_sql: {
+                    readonly icon: "DatabaseEditOutline";
+                    readonly annotations: {
+                        readonly readOnlyHint: false;
+                        readonly destructiveHint: true;
+                    };
+                    readonly description: "Executes a SQL query on the connected database in commit mode (data can be changed, the transaction committed at the end).";
+                    readonly schema: {
+                        readonly type: {
+                            readonly sql: {
+                                readonly type: "string";
+                                readonly description: "SQL query to execute";
+                            };
+                            readonly query_timeout: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                            };
+                            readonly query_params: {
+                                readonly optional: true;
+                                readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                                readonly oneOf: readonly ["any[]", {
+                                    readonly record: {
+                                        readonly values: "any";
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    };
+                };
+                readonly count: {
+                    readonly icon: "DatabaseEyeOutline";
+                    readonly description: "Counts rows in a table that satisfy a filter.";
+                    readonly annotations: {
+                        readonly readOnlyHint: true;
+                    };
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableName: "string";
+                            readonly filter: {
+                                readonly optional: true;
+                                readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                        };
+                    };
+                    readonly outputSchema: "number";
+                };
+                readonly find: {
+                    readonly icon: "TableSearch";
+                    readonly description: "Selects rows from a table.";
+                    readonly annotations: {
+                        readonly readOnlyHint: true;
+                    };
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableName: "string";
+                            readonly filter: {
+                                readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                                readonly optional: true;
+                            };
+                            readonly select: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly enum: readonly ["*"];
+                                }, {
+                                    readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly enum: readonly [1, 0];
+                                        };
+                                    };
+                                }];
+                            };
+                            readonly orderBy: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly arrayOfType: {
+                                        readonly key: "string";
+                                        readonly asc: {
+                                            readonly enum: readonly [true, false];
+                                        };
+                                        readonly nulls: {
+                                            readonly enum: readonly ["first", "last"];
+                                            readonly optional: true;
+                                        };
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly key: "string";
+                                        readonly asc: {
+                                            readonly enum: readonly [true, false];
+                                        };
+                                        readonly nulls: {
+                                            readonly enum: readonly ["first", "last"];
+                                            readonly optional: true;
+                                        };
+                                    };
+                                }];
+                            };
+                            readonly limit: {
+                                readonly optional: true;
+                                readonly description: "Defaults to 10";
+                                readonly type: "integer";
+                            };
+                            readonly offset: {
+                                readonly optional: true;
+                                readonly type: "integer";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    };
+                };
+                readonly insert: {
+                    readonly icon: "TablePlus";
+                    readonly description: "Inserts a row into a table.";
+                    readonly annotations: {
+                        readonly readOnlyHint: false;
+                    };
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableName: "string";
+                            readonly data: {
+                                readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                            readonly onConflict: {
+                                readonly enum: readonly ["DoNothing", "DoUpdate"];
+                                readonly optional: true;
+                                readonly description: string;
+                            };
+                            readonly returning: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly enum: readonly ["*"];
+                                }, {
+                                    readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly enum: readonly [1, 0];
+                                        };
+                                    };
+                                }];
+                                readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly optional: true;
+                        readonly description: "Inserted row returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+                readonly insertMany: {
+                    readonly icon: "TablePlus";
+                    readonly description: "Inserts rows into a table.";
+                    readonly annotations: {
+                        readonly readOnlyHint: false;
+                    };
+                    readonly schema: {
+                        readonly type: {
+                            readonly tableName: "string";
+                            readonly data: {
+                                readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                                readonly arrayOf: {
+                                    readonly record: {
+                                        readonly values: "any";
+                                    };
+                                };
+                            };
+                            readonly onConflict: {
+                                readonly enum: readonly ["DoNothing", "DoUpdate"];
+                                readonly optional: true;
+                                readonly description: string;
+                            };
+                            readonly returning: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly enum: readonly ["*"];
+                                }, {
+                                    readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly enum: readonly [1, 0];
+                                        };
+                                    };
+                                }];
+                                readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly optional: true;
+                        readonly description: "Inserted rows returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                    };
+                };
+                readonly update: {
+                    readonly icon: "TableEdit";
+                    readonly description: "Updates rows in a table.";
+                    readonly annotations: {
+                        readonly destructiveHint: true;
+                        readonly readOnlyHint: false;
+                    };
+                    readonly schema: {
+                        readonly type: {
+                            readonly data: {
+                                readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                            readonly removeDisallowedFields: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "Whether to remove fields that are not allowed to be updated instead of throwing an error.";
+                            };
+                            readonly multi: {
+                                readonly description: "true by default. When set to false the update will throw an error if more than one row is updated (but the update will commit).";
+                                readonly type: "boolean";
+                                readonly optional: true;
+                            };
+                            readonly returning: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly enum: readonly ["*"];
+                                }, {
+                                    readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly enum: readonly [1, 0];
+                                        };
+                                    };
+                                }];
+                                readonly description: "Fields to return for updated data. Nothing will be returned otherwise";
+                            };
+                            readonly filter: {
+                                readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                            readonly tableName: "string";
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly optional: true;
+                        readonly oneOf: readonly [{
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        }, {
+                            readonly arrayOf: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                        }];
+                    };
+                };
+                readonly delete: {
+                    readonly icon: "TableRemove";
+                    readonly annotations: {
+                        readonly destructiveHint: true;
+                        readonly readOnlyHint: false;
+                    };
+                    readonly description: "Deletes rows from a table.";
+                    readonly schema: {
+                        readonly type: {
+                            readonly returning: {
+                                readonly optional: true;
+                                readonly oneOf: readonly [{
+                                    readonly enum: readonly ["*"];
+                                }, {
+                                    readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly enum: readonly [1, 0];
+                                        };
+                                    };
+                                }];
+                                readonly description: "Fields to return for the deleted rows. Nothing will be returned otherwise";
+                            };
+                            readonly filter: {
+                                readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                            readonly tableName: "string";
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly oneOf: readonly [{
+                            readonly arrayOf: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                        }, {
+                            readonly enum: readonly [undefined];
+                        }];
+                    };
+                };
+            };
+            readonly config_schema: undefined;
+        };
+        handler: ProstglesMcpServerHandler;
+    };
+    readonly documents: {
+        definition: {
+            readonly icon_path: "TextBoxSearchOutline";
+            readonly label: "Documents";
+            readonly description: "Convert documents to text and extract information from them";
+            readonly tools: {
+                readonly get_document_text: {
+                    readonly mode: undefined;
+                    readonly description: "Converts documents/images into structured data. Supported formats: txt, pdf, docx, pptx, jpg, png, and more. Powered by [docling](https://www.docling.ai/).";
+                    readonly schema: {
+                        readonly type: {
+                            readonly to_format: {
+                                readonly optional: true;
+                                readonly description: "Defaults to \"md\". Convert the document to a specific format.";
+                                readonly enum: readonly ["md", "json", "yaml", "html", "html_split_page", "text", "doctags"];
+                            };
+                            readonly from_formats: {
+                                readonly optional: true;
+                                readonly type: "string[]";
+                                readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                            };
+                            readonly image_export_mode: {
+                                readonly optional: true;
+                                readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                                readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                            };
+                            readonly page_range: {
+                                readonly tuple: readonly ["number", "number"];
+                                readonly optional: true;
+                                readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                            };
+                            readonly do_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                            };
+                            readonly force_ocr: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                            };
+                            readonly ocr_engine: {
+                                readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                                readonly optional: true;
+                                readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                            };
+                            readonly ocr_lang: {
+                                readonly type: "string[]";
+                                readonly optional: true;
+                                readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                            };
+                            readonly document_timeout: {
+                                readonly optional: true;
+                                readonly type: "number";
+                                readonly description: "The timeout for processing each document, in seconds.";
+                            };
+                            readonly pdf_backend: {
+                                readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                                readonly optional: true;
+                                readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                            };
+                            readonly table_mode: {
+                                readonly enum: readonly ["fast", "accurate"];
+                                readonly optional: true;
+                                readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                            };
+                            readonly do_table_structure: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                            };
+                            readonly include_images: {
+                                readonly type: "boolean";
+                                readonly optional: true;
+                                readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                            };
+                            readonly md_page_break_placeholder: {
+                                readonly type: "string";
+                                readonly optional: true;
+                                readonly description: "Add this placeholder between pages in the markdown output.";
+                            };
+                            readonly images_scale: {
+                                readonly type: "number";
+                                readonly optional: true;
+                                readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                            };
+                            readonly fileAsBase64: "string";
+                            readonly contentType: {
+                                readonly enum: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "image/png", "image/jpeg", "image/tiff", "image/bmp", "image/webp"];
+                            };
+                        };
+                    };
+                    readonly outputSchema: {
+                        readonly type: "string";
+                    };
+                };
+            };
+            readonly config_schema: undefined;
+        };
+        handler: ProstglesMcpServerHandler;
+    };
+};
+export declare const getProstglesMCPServer: (serverName: string) => {
+    definition: {
+        readonly icon_path: "Web";
+        readonly label: "Web Search";
+        readonly description: "Search the web for information";
+        readonly config_schema: {
+            readonly access: {
+                readonly renderWithComponent: "WebMcpConfig";
+                readonly type: {
+                    readonly mode: {
+                        readonly enum: readonly ["allow", "deny", "unrestricted"];
+                        readonly description: "Access control mode. 'allow' means only URLs matching the patterns in 'hosts' are allowed. 'deny' means URLs matching the patterns are blocked. 'unrestricted' means no URL filtering or blockedSubnet check is applied.";
+                    };
+                    readonly urls: {
+                        readonly type: "string[]";
+                        readonly description: "URL Patterns can be simple substrings (e.g., 'example.com') or wildcard patterns (e.g., '*.example.com'). The 'mode' field determines whether these patterns define allowed URLs or blocked URLs.";
+                    };
+                    readonly blockInternalSubnets: {
+                        readonly type: "boolean";
+                        readonly optional: true;
+                        readonly description: "If true, the server will block requests to IP addresses in common internal subnets (e.g., localhost, private network ranges) in addition to any user-defined blocked subnets. Defaults to true.";
+                    };
+                    readonly internalSubnets: {
+                        readonly optional: true;
+                        readonly type: "string[]";
+                        readonly description: "Optional list of IP subnets in CIDR notation";
+                    };
+                };
+                readonly defaultValue: {
+                    readonly mode: "deny";
+                    readonly urls: readonly [];
+                    readonly blockInternalSubnets: true;
+                    readonly internalSubnets: string[];
+                };
+            };
+        };
+        readonly tools: {
+            readonly fetch: {
+                readonly description: "Fetches from a URL, with optional conversion for documents. DO NOT USE THIS TO FETCH WEBSITE HTML. Use the get_snapshot tool instead.";
+                readonly schema: {
+                    readonly type: {
+                        readonly url: {
+                            readonly type: "string";
+                            readonly description: "URL of the content to fetch";
+                        };
+                        readonly method: {
+                            readonly enum: readonly ["GET", "POST", "PUT", "DELETE", "PATCH"];
+                            readonly optional: true;
+                            readonly description: "HTTP method to use for the request. Defaults to GET.";
+                        };
+                        readonly body: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Request body for POST, PUT, or PATCH requests. Ignored for GET and DELETE requests.";
+                        };
+                        readonly mode: {
+                            readonly enum: readonly ["raw", "convert"];
+                            readonly optional: true;
+                            readonly description: "Defaults to raw. raw = fetch raw content without conversion. convert = attempt document conversion if the URL points to a document. Supported formats include txt, pdf, docx, pptx, jpg, png, and more.";
+                        };
+                        readonly headers: {
+                            readonly optional: true;
+                            readonly record: {
+                                readonly values: "string";
+                            };
+                        };
+                        readonly start_index: {
+                            readonly type: "integer";
+                            readonly optional: true;
+                            readonly description: "Starting index for slicing the fetched content. Defaults to 0.";
+                        };
+                        readonly max_length: {
+                            readonly type: "integer";
+                            readonly optional: true;
+                            readonly description: "Maximum length of the returned content slice. Defaults to returning the full content.";
+                        };
+                        readonly timeout: {
+                            readonly type: "integer";
+                            readonly optional: true;
+                            readonly description: "Maximum time in milliseconds to wait for the fetch operation. Defaults to 15000 (15 seconds).";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+            readonly websearch: {
+                readonly description: "Performs a web search and return results. Powered by [SearXNG](https://docs.searxng.org/)";
+                readonly schema: {
+                    readonly type: {
+                        readonly q: {
+                            readonly type: "string";
+                            readonly description: "The search query. This string is passed to external search services. Supports service-specific syntax (e.g., \"site:github.com SearXNG\" for Google)";
+                        };
+                        readonly categories: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: " Comma-separated list of active search categories. Categories to search in (e.g., 'general,images,videos')";
+                        };
+                        readonly engines: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Comma-separated list of active search engines (e.g., 'google,bing,duckduckgo')";
+                        };
+                        readonly language: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Language code for the search results (e.g., 'en' for English, 'fr' for French)";
+                        };
+                        readonly pageno: {
+                            readonly type: "integer";
+                            readonly optional: true;
+                            readonly description: "Search result page number. Defaults to 1.";
+                        };
+                        readonly time_range: {
+                            readonly enum: readonly ["day", "month", "year"];
+                            readonly optional: true;
+                            readonly description: "Time range filter for results ('day' = past day, 'month' = past month, 'year' = past year). Only supported by engines that implement time range filtering";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOfType: {
+                        readonly title: "string";
+                        readonly content: "string";
+                        readonly url: "string";
+                        readonly score: "number";
+                        readonly category: "string";
+                        readonly engine: "string";
+                        readonly img_src: "string";
+                        readonly thumbnail: "any";
+                        readonly template: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly publishedDate: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly parsed_url: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly priority: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly engines: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly positions: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                        readonly pubdate: {
+                            readonly optional: true;
+                            readonly type: "any";
+                        };
+                    };
+                };
+            };
+            readonly get_snapshot: {
+                readonly description: "Get a snapshot of a web page";
+                readonly schema: {
+                    readonly type: {
+                        readonly url: {
+                            readonly type: "string";
+                            readonly description: "URL of the web page to snapshot";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+            readonly get_document_text: {
+                readonly description: "Get text contents of a document";
+                readonly schema: {
+                    readonly type: {
+                        readonly url: {
+                            readonly type: "string";
+                        };
+                        readonly from_formats: {
+                            readonly optional: true;
+                            readonly type: "string[]";
+                            readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                        };
+                        readonly image_export_mode: {
+                            readonly optional: true;
+                            readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                            readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                        };
+                        readonly page_range: {
+                            readonly tuple: readonly ["number", "number"];
+                            readonly optional: true;
+                            readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                        };
+                        readonly do_ocr: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                        };
+                        readonly force_ocr: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                        };
+                        readonly ocr_engine: {
+                            readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                            readonly optional: true;
+                            readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                        };
+                        readonly ocr_lang: {
+                            readonly type: "string[]";
+                            readonly optional: true;
+                            readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                        };
+                        readonly document_timeout: {
+                            readonly optional: true;
+                            readonly type: "number";
+                            readonly description: "The timeout for processing each document, in seconds.";
+                        };
+                        readonly pdf_backend: {
+                            readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                            readonly optional: true;
+                            readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                        };
+                        readonly table_mode: {
+                            readonly enum: readonly ["fast", "accurate"];
+                            readonly optional: true;
+                            readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                        };
+                        readonly do_table_structure: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                        };
+                        readonly include_images: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                        };
+                        readonly md_page_break_placeholder: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Add this placeholder between pages in the markdown output.";
+                        };
+                        readonly images_scale: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+        };
+    };
+    handler: ProstglesMcpServerHandler;
+} | {
+    definition: {
+        readonly icon_path: "React";
+        readonly label: "Web Dev Environment";
+        readonly description: "React vite based web development environment.";
+        readonly config_schema: undefined;
+        readonly tools: {
+            readonly list_directory: {
+                readonly description: "List files in the web app directory. Will truncate long lists.";
+                readonly schema: {
+                    readonly type: {
+                        readonly directoryPath: {
+                            readonly type: "string";
+                            readonly description: "Directory path to list files from the web app directory. Example: 'src/components'";
+                            readonly optional: true;
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: "string";
+                };
+            };
+            readonly read_files: {
+                readonly description: "Read files from the web app directory";
+                readonly schema: {
+                    readonly type: {
+                        readonly filePaths: {
+                            readonly description: "File paths to read from the web app directory.";
+                            readonly arrayOf: "string";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOfType: {
+                        readonly filePath: "string";
+                        readonly content: "string";
+                    };
+                };
+            };
+            readonly search_files: {
+                readonly description: "Search files by content and/or file name in the web app directory";
+                readonly schema: {
+                    readonly type: {
+                        readonly contentQuery: {
+                            readonly type: "string";
+                            readonly description: "File content search query. Example: 'useState' to search for files that include 'useState'";
+                            readonly optional: true;
+                        };
+                        readonly fileNameQuery: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "File name search query to further filter search results. Example: 'Counter' to only include files with 'Counter' in the file name.";
+                        };
+                        readonly extensions: {
+                            readonly description: "File extensions to limit the search to (e.g., ['ts', 'tsx', 'js', 'jsx'])";
+                            readonly arrayOf: "string";
+                            readonly optional: true;
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOfType: {
+                        readonly filePath: "string";
+                        readonly matchedContent: "string";
+                    };
+                };
+            };
+            readonly create_component_quick_feedback_preview: {
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly indexTsx: {
+                            readonly type: "string";
+                            readonly description: "tsx code for the component. Example: 'import { useState } from \"react\"; ...'";
+                        };
+                        readonly css: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "css code for the component. Example: '.container { display: flex; }'";
+                        };
+                        readonly dependencies: {
+                            readonly description: "Dependencies to install in the environment (e.g., react, axios)";
+                            readonly arrayOf: "string";
+                            readonly optional: true;
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "unknown";
+                };
+            };
+            readonly create_component: {
+                readonly description: "Create a react component";
+                readonly schema: {
+                    readonly type: {
+                        readonly entryPoint: {
+                            readonly type: "string";
+                            readonly description: "Entry point file for the component. Example: '@/components/Counter/Counter.tsx'";
+                        };
+                        readonly files: {
+                            readonly description: "tsx/css and other files for the component. Example: { \"@/components/Counter/Counter.tsx\":  \"import { useState } from \"react\"; ...\"  } ";
+                            readonly record: {
+                                readonly values: "string";
+                            };
+                        };
+                        readonly dependencies: {
+                            readonly description: "Dependencies to install in the environment (e.g., react, axios)";
+                            readonly arrayOf: "string";
+                            readonly optional: true;
+                        };
+                        readonly devDependencies: {
+                            readonly description: "Dev Dependencies to install in the environment (e.g., @types/pkg)";
+                            readonly arrayOf: "string";
+                            readonly optional: true;
+                        };
+                        readonly test: {
+                            readonly description: "Playwright test to run against the component. Example:  'import { test, expect } from \"@playwright/react\"; ...'";
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "unknown";
+                };
+            };
+        };
+    };
+    handler: ProstglesMcpServerHandler;
+} | {
+    definition: {
+        readonly icon_path: "CubeOutline";
+        readonly label: "Prostgles";
+        readonly description: "Tools to assist with Prostgles UI tasks";
+        readonly config_schema: undefined;
+        readonly tools: {
+            readonly compact_context: {
+                readonly icon: "ArrowCollapse";
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly type: {
+                            readonly enum: readonly ["conversation", "previous-message"];
+                        };
+                        readonly summary: {
+                            readonly type: "string";
+                            readonly description: "When type=conversation it is a summary of the conversation so far. When type=previous-message it is a summary of the previous message.";
+                        };
+                    };
+                };
+                readonly outputSchema: "string";
+            };
+            readonly run_code_in_sandbox: {
+                readonly icon: "Docker";
+                readonly annotations: {
+                    readonly openWorldHint: true;
+                };
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly reason: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Reason for executing the code to provide context to the user. One short sentence is enough. ";
+                        };
+                        readonly files: {
+                            readonly description: string;
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly type: "string";
+                                    readonly description: "File content. E.g.: 'import type { JSONB } from \"prostgles-types\";' ";
+                                };
+                            };
+                        };
+                        readonly userInputValue: {
+                            readonly optional: true;
+                            readonly description: "User populated values for the userInput keys. It will override the default values in userInput if provided. ";
+                            readonly record: {
+                                readonly values: "unknown";
+                            };
+                        };
+                        readonly timeout: {
+                            readonly optional: true;
+                            readonly type: "integer";
+                            readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                        };
+                        readonly networkMode: {
+                            readonly optional: true;
+                            readonly enum: readonly ["none", "bridge", "bridge-internal", "host"];
+                            readonly description: "Network mode for the container. Defaults to 'bridge-internal'. Use 'bridge' mode to be able to access the database. Use 'bridge-internal' to access the database but not the internet.";
+                        };
+                        readonly environment: {
+                            readonly optional: true;
+                            readonly description: "Environment variables to set in the container";
+                            readonly record: {
+                                readonly values: "string";
+                                readonly partial: true;
+                            };
+                        };
+                        readonly memory: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                        };
+                        readonly cpus: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                        };
+                        readonly readOnly: {
+                            readonly optional: true;
+                            readonly type: "boolean";
+                            readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                        };
+                        readonly userInput: {
+                            readonly description: string;
+                            readonly optional: true;
+                            readonly record: {
+                                readonly values: {
+                                    readonly oneOfType: readonly [{
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-column-value"];
+                                        };
+                                        readonly tableName: "string";
+                                        readonly columnName: "string";
+                                        readonly defaultValue: {
+                                            readonly type: "any";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-column-values"];
+                                        };
+                                        readonly tableName: "string";
+                                        readonly columnName: "string";
+                                        readonly defaultValue: {
+                                            readonly type: "any[]";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-filter"];
+                                        };
+                                        readonly tableName: "string";
+                                        readonly defaultValue: {
+                                            readonly record: {
+                                                readonly values: "any";
+                                            };
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-column"];
+                                        };
+                                        readonly tableName: "string";
+                                        readonly defaultValue: {
+                                            readonly type: "string";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-name"];
+                                        };
+                                        readonly defaultValue: {
+                                            readonly type: "string";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["table-and-column"];
+                                        };
+                                        readonly defaultValue: {
+                                            readonly type: {
+                                                readonly tableName: "string";
+                                                readonly columnName: "string";
+                                            };
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["enum"];
+                                        };
+                                        readonly values: "string[]";
+                                        readonly defaultValue: {
+                                            readonly type: "string";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["custom"];
+                                        };
+                                        readonly dataType: {
+                                            readonly enum: readonly ["string", "number", "boolean", "Date"];
+                                        };
+                                        readonly defaultValue: {
+                                            readonly type: "unknown";
+                                            readonly optional: true;
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["folder-path", "file-path", "file-or-folder-path"];
+                                        };
+                                        readonly accessMode: {
+                                            readonly enum: readonly ["read", "read-write"];
+                                        };
+                                    }, {
+                                        readonly title: "string";
+                                        readonly optional: {
+                                            readonly type: "boolean";
+                                            readonly optional: true;
+                                        };
+                                        readonly type: {
+                                            readonly enum: readonly ["folder-paths", "file-paths", "file-or-folder-paths"];
+                                        };
+                                        readonly accessMode: {
+                                            readonly enum: readonly ["read", "read-write"];
+                                        };
+                                    }];
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: {
+                        readonly state: {
+                            readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+                        };
+                        readonly name: "string";
+                        readonly command: "string";
+                        readonly log: {
+                            readonly arrayOfType: {
+                                readonly type: {
+                                    readonly enum: readonly ["stdout", "stderr", "error"];
+                                };
+                                readonly text: "string";
+                            };
+                        };
+                        readonly exitCode: "number";
+                        readonly runDuration: "number";
+                        readonly buildDuration: "number";
+                    };
+                };
+            };
+            readonly run_typescript_in_nodejs: {
+                readonly icon: "Nodejs";
+                readonly annotations: {
+                    readonly openWorldHint: true;
+                };
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly reason: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Reason for executing the code to provide context to the user. One short sentence is enough. ";
+                        };
+                        readonly timeout: {
+                            readonly optional: true;
+                            readonly type: "integer";
+                            readonly description: "Maximum time in milliseconds the container will be allowed to run. Defaults to 30000. ";
+                        };
+                        readonly networkMode: {
+                            readonly optional: true;
+                            readonly enum: readonly ["none", "bridge", "bridge-internal", "host"];
+                            readonly description: "Network mode for the container. Defaults to 'bridge-internal'. Use 'bridge' mode to be able to access the database. Use 'bridge-internal' to access the database but not the internet.";
+                        };
+                        readonly environment: {
+                            readonly optional: true;
+                            readonly description: "Environment variables to set in the container";
+                            readonly record: {
+                                readonly values: "string";
+                                readonly partial: true;
+                            };
+                        };
+                        readonly memory: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "Memory limit (e.g., '512m', '1g'). Defaults to 512m";
+                        };
+                        readonly cpus: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "CPU limit (e.g., '0.5', '1'). Defaults to 1";
+                        };
+                        readonly readOnly: {
+                            readonly optional: true;
+                            readonly type: "boolean";
+                            readonly description: "Whether to mount the filesystem as read-only. Defaults to true";
+                        };
+                        readonly entrypointTs: {
+                            readonly type: "string";
+                            readonly description: "Typescript code to execute. Must compile with no errors assuming strict tsconfig and recommended eslint rules.";
+                        };
+                        readonly packageDependencies: {
+                            readonly optional: true;
+                            readonly description: "Dependencies to install in the container. Must be reputable npm packages. Example: { \"prostgles-types\": \"^4.0.217\" }";
+                            readonly record: {
+                                readonly values: "string";
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: {
+                        readonly state: {
+                            readonly enum: readonly ["finished", "error", "build-error", "timed-out", "aborted"];
+                        };
+                        readonly name: "string";
+                        readonly command: "string";
+                        readonly log: {
+                            readonly arrayOfType: {
+                                readonly type: {
+                                    readonly enum: readonly ["stdout", "stderr", "error"];
+                                };
+                                readonly text: "string";
+                            };
+                        };
+                        readonly exitCode: "number";
+                        readonly runDuration: "number";
+                        readonly buildDuration: "number";
+                    };
+                };
+            };
+            readonly ask_user_questions: {
+                readonly icon: "AccountQuestionOutline";
+                readonly mode: "user-provides-response";
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly questions: {
+                            readonly arrayOf: {
+                                readonly oneOfType: readonly [{
+                                    readonly type: {
+                                        readonly enum: readonly ["choice"];
+                                    };
+                                    readonly question: {
+                                        readonly type: "string";
+                                        readonly description: "The question to ask the user";
+                                    };
+                                    readonly allowMultipleChoices: {
+                                        readonly type: "boolean";
+                                        readonly optional: true;
+                                        readonly description: "If true, the user can select multiple choices. Defaults to false.";
+                                    };
+                                    readonly suggestedAnswers: {
+                                        readonly description: "The list of suggested answers the user will choose from";
+                                        readonly arrayOf: "string";
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly enum: readonly ["free-text"];
+                                    };
+                                    readonly question: {
+                                        readonly type: "string";
+                                        readonly description: "The question to ask the user";
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly enum: readonly ["table-name"];
+                                    };
+                                    readonly question: {
+                                        readonly type: "string";
+                                        readonly description: "The question to ask the user";
+                                    };
+                                    readonly suggestedTableName: {
+                                        readonly type: "string";
+                                        readonly optional: true;
+                                    };
+                                }, {
+                                    readonly type: {
+                                        readonly enum: readonly ["table-columns"];
+                                    };
+                                    readonly tableName: "string";
+                                    readonly question: {
+                                        readonly type: "string";
+                                        readonly description: "The question to ask the user";
+                                    };
+                                    readonly suggestedColumns: {
+                                        readonly type: "string[]";
+                                        readonly optional: true;
+                                    };
+                                }];
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOfType: {
+                        readonly question: "string";
+                        readonly answers: "string[]";
+                    };
+                };
+            };
+            readonly get_tool_list: {
+                readonly icon: "Tools";
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {};
+                };
+                readonly outputSchema: {
+                    readonly arrayOfType: {
+                        readonly server_name: "string";
+                        readonly tool_name: "string";
+                    };
+                };
+            };
+            readonly get_specific_tool_schemas: {
+                readonly icon: "Tools";
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly mcpServerTools: {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            };
+                            readonly description: string;
+                        };
+                        readonly infoLevel: {
+                            readonly optional: true;
+                            readonly enum: readonly ["full", "basic"];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly record: {
+                        readonly values: {
+                            readonly record: {
+                                readonly values: {
+                                    readonly type: {
+                                        readonly description: "string";
+                                        readonly tsDefinition: "string";
+                                        readonly inputSchema: {
+                                            readonly record: {
+                                                readonly values: "unknown";
+                                            };
+                                        };
+                                        readonly outputSchema: {
+                                            readonly nullable: true;
+                                            readonly record: {
+                                                readonly values: "unknown";
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+            readonly request_tool_access: {
+                readonly icon: "LockQuestion";
+                readonly mode: "auto-approved-user-actionable";
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly reason: {
+                            readonly description: "Reason for requesting access to the tool";
+                            readonly type: "string";
+                            readonly optional: true;
+                        };
+                        readonly mcpServerTools: {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            };
+                            readonly description: "List of MCP server tools to enable for this chat. Example: { web: { fetch: 1 } }";
+                            readonly optional: true;
+                        };
+                        readonly databaseAccess: {
+                            readonly optional: true;
+                            readonly description: "Database access configuration. Use the most restrictive access type that is needed to complete the task.";
+                            readonly oneOfType: readonly [{
+                                readonly mode: {
+                                    readonly enum: readonly ["execute_readonly_sql"];
+                                };
+                            }, {
+                                readonly mode: {
+                                    readonly enum: readonly ["execute_sql"];
+                                };
+                                readonly allowedCommands: {
+                                    readonly optional: true;
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly keysEnum: readonly ["select", "insert", "update", "delete"];
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            }, {
+                                readonly mode: {
+                                    readonly enum: readonly ["custom"];
+                                };
+                                readonly tablePermissions: {
+                                    readonly title: "Tables";
+                                    readonly description: "Tables the assistant can access";
+                                    readonly record: {
+                                        readonly values: {
+                                            readonly type: {
+                                                readonly select: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly enum: readonly [true];
+                                                    }, {
+                                                        readonly type: {
+                                                            readonly forcedFilter: {
+                                                                readonly optional: true;
+                                                                readonly oneOfType: readonly [{
+                                                                    readonly $and: "any[]";
+                                                                }, {
+                                                                    readonly $or: "any[]";
+                                                                }];
+                                                            };
+                                                            readonly fields: {
+                                                                readonly oneOf: readonly [{
+                                                                    readonly enum: readonly ["*"];
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [1];
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [0];
+                                                                        };
+                                                                    };
+                                                                }];
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly optional: true;
+                                                };
+                                                readonly update: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly enum: readonly [true];
+                                                    }, {
+                                                        readonly type: {
+                                                            readonly forcedFilter: {
+                                                                readonly optional: true;
+                                                                readonly oneOfType: readonly [{
+                                                                    readonly $and: "any[]";
+                                                                }, {
+                                                                    readonly $or: "any[]";
+                                                                }];
+                                                            };
+                                                            readonly fields: {
+                                                                readonly oneOf: readonly [{
+                                                                    readonly enum: readonly ["*"];
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [1];
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [0];
+                                                                        };
+                                                                    };
+                                                                }];
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly optional: true;
+                                                };
+                                                readonly insert: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly enum: readonly [true];
+                                                    }, {
+                                                        readonly type: {
+                                                            readonly fields: {
+                                                                readonly oneOf: readonly [{
+                                                                    readonly enum: readonly ["*"];
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [1];
+                                                                        };
+                                                                    };
+                                                                }, {
+                                                                    readonly record: {
+                                                                        readonly values: {
+                                                                            readonly enum: readonly [0];
+                                                                        };
+                                                                    };
+                                                                }];
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly optional: true;
+                                                };
+                                                readonly delete: {
+                                                    readonly oneOf: readonly [{
+                                                        readonly enum: readonly [true];
+                                                    }, {
+                                                        readonly type: {
+                                                            readonly forcedFilter: {
+                                                                readonly optional: true;
+                                                                readonly oneOfType: readonly [{
+                                                                    readonly $and: "any[]";
+                                                                }, {
+                                                                    readonly $or: "any[]";
+                                                                }];
+                                                            };
+                                                        };
+                                                    }];
+                                                    readonly optional: true;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            }];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: {
+                        readonly validatedTools: {
+                            readonly arrayOfType: {
+                                readonly id: "number";
+                                readonly server_name: "string";
+                                readonly config_id: {
+                                    readonly oneOf: readonly ["number", {
+                                        readonly enum: readonly [null];
+                                    }];
+                                };
+                            };
+                        };
+                        readonly status: {
+                            readonly optional: true;
+                            readonly enum: readonly ["approved", "denied"];
+                        };
+                    };
+                };
+            };
+            readonly create_tables: {
+                readonly icon: "TablePlus";
+                readonly mode: undefined;
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly ddlStatements: {
+                            readonly description: "SQL DDL statements to create tables. Only CREATE TABLE, CREATE VIEW and CREATE INDEX statements are allowed.";
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: {
+                        readonly data: "unknown[]";
+                    };
+                };
+            };
+            readonly create_agent: {
+                readonly icon: "RobotOutline";
+                readonly mode: "always-needs-approval";
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly tools: {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly record: {
+                                        readonly partial: true;
+                                        readonly values: {
+                                            readonly enum: readonly [1];
+                                        };
+                                    };
+                                };
+                            };
+                            readonly description: "List of MCP server tools available to the agent. Example: { web: { fetch: 1 } }";
+                            readonly optional: true;
+                        };
+                        readonly firstMessage: {
+                            readonly description: "The first message to send to the agent. If not provided, the agent will start with an empty message.";
+                            readonly optional: true;
+                            readonly type: "string";
+                        };
+                        readonly prompt: {
+                            readonly type: "string";
+                        };
+                        readonly modelName: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "The name of the LLM model to use for this agent. If not provided, the default model will be used.";
+                        };
+                        readonly maxCostUSD: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "The maximum cost in USD that this agent is allowed to incur.";
+                        };
+                        readonly maxIterations: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "The maximum number of iterations this agent is allowed to run.";
+                        };
+                        readonly mcpServerConfigs: {
+                            readonly optional: true;
+                            readonly description: "SYSTEM ONLY — DO NOT SPECIFY: Do not generate, invent, or prompt the user for configuration IDs. This field is automatically injected by the host runtime when a tool requires user-provided MCP server authorization.";
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly type: {
+                                        readonly configId: {
+                                            readonly type: "number";
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        readonly maxTokens: {
+                            readonly type: "number";
+                            readonly optional: true;
+                        };
+                        readonly temperature: {
+                            readonly type: "number";
+                            readonly optional: true;
+                        };
+                        readonly name: "string";
+                        readonly autoApproveAllTools: "boolean";
+                        readonly timeout: "integer";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly oneOfType: readonly [{
+                        readonly success: {
+                            readonly enum: readonly [true];
+                        };
+                        readonly result: "string";
+                    }, {
+                        readonly success: {
+                            readonly enum: readonly [false];
+                        };
+                        readonly error: "string";
+                    }];
+                };
+            };
+            readonly create_agentic_workflow: {
+                readonly icon: "CubeOutline";
+                readonly mode: "auto-approved-user-actionable";
+                readonly description: "Creates an agentic workflow which is executed manually by the user to iteratively complete the specified task using MCP tools and database access if needed. Runtime logs are only visible to the user. Definition validation is not a substitute for testing external runtime assumptions";
+                readonly schema: {
+                    readonly type: {
+                        readonly workflow_function_definition: {
+                            readonly type: "string";
+                            readonly description: "Typescript code defining a function that returns an agent workflow. The function must satisfy the following type provided. The function can use available MCP tools and database access if needed. Available MCP tools and database access are determined by the fetchTools function and the input to this tool.";
+                        };
+                        readonly workflow_function_definition_summary: {
+                            readonly type: "string";
+                            readonly description: "A concise summary of the workflow function definition for the user to understand what the workflow does without having to read the code. This will be shown to the user when asking for approval to run the workflow.";
+                        };
+                        readonly package_dependencies: {
+                            readonly optional: true;
+                            readonly description: "A list of npm packages to be added to the container package.json dependencies.";
+                            readonly record: {
+                                readonly values: "string";
+                            };
+                        };
+                        readonly workflowId: {
+                            readonly type: "integer";
+                            readonly optional: true;
+                            readonly description: "FOR INTERNAL USE ONLY. DO NOT ASK USER ABOUT THIS. Workflow ID to update instead of creating a new workflow. If not provided, a new workflow will be created.";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly oneOfType: readonly [{
+                        readonly isValid: {
+                            readonly enum: readonly [true];
+                        };
+                        readonly workflowId: "number";
+                    }, {
+                        readonly isValid: {
+                            readonly enum: readonly [false];
+                        };
+                        readonly logs: "string";
+                        readonly error: {
+                            readonly type: "unknown";
+                            readonly optional: true;
+                        };
+                    }];
+                };
+            };
+            readonly get_tables_metadata: {
+                readonly icon: "Table";
+                readonly mode: undefined;
+                readonly description: "Get rendering metadata for database tables.";
+                readonly schema: {
+                    readonly type: {
+                        readonly tableNames: "string[]";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "unknown";
+                };
+            };
+            readonly set_tables_metadata: {
+                readonly icon: "Table";
+                readonly mode: undefined;
+                readonly description: "Set rendering metadata for database tables";
+                readonly schema: {
+                    readonly type: {
+                        readonly metadata: {
+                            readonly record: {
+                                readonly partial: true;
+                                readonly values: {
+                                    readonly type: {
+                                        readonly icon: {
+                                            readonly type: "string";
+                                            readonly description: "MDI Icon name. For example: 'AccessPointNetwork', 'Github'";
+                                            readonly optional: true;
+                                        };
+                                        readonly label: {
+                                            readonly type: "string";
+                                            readonly optional: true;
+                                        };
+                                        readonly sort: {
+                                            readonly optional: true;
+                                            readonly description: "Default sort order for new table views";
+                                            readonly arrayOfType: {
+                                                readonly key: "string";
+                                                readonly asc: "boolean";
+                                                readonly nulls: {
+                                                    readonly enum: readonly ["first", "last"];
+                                                    readonly optional: true;
+                                                };
+                                            };
+                                        };
+                                        readonly rowIconColumn: {
+                                            readonly type: "string";
+                                            readonly description: "Column name that contains url to a local icon (in /icons folder) to be shown as an icon in each row. This is used in card and table views.";
+                                            readonly optional: true;
+                                        };
+                                        readonly columns: {
+                                            readonly optional: true;
+                                            readonly record: {
+                                                readonly partial: true;
+                                                readonly values: {
+                                                    readonly type: {
+                                                        readonly icon: {
+                                                            readonly type: "string";
+                                                            readonly optional: true;
+                                                        };
+                                                        readonly renderAs: {
+                                                            readonly optional: true;
+                                                            readonly title: "Display format";
+                                                            readonly description: "Control how data is displayed";
+                                                            readonly oneOfType: readonly [{
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["NONE"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display data as is. Default";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["URL"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Clickable URL";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Email"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Email link";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Tel"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Telephone number link";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["QR Code"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display a URL as an image";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly title: "Format";
+                                                                    readonly enum: readonly ["Currency"];
+                                                                    readonly description: "With currency symbol";
+                                                                };
+                                                                readonly params: {
+                                                                    readonly oneOfType: readonly [{
+                                                                        readonly mode: {
+                                                                            readonly enum: readonly ["Fixed"];
+                                                                            readonly title: "Type";
+                                                                        };
+                                                                        readonly metricPrefix: {
+                                                                            readonly type: "boolean";
+                                                                            readonly title: "Use Metric Prefix";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly currencyCode: {
+                                                                            readonly type: "string";
+                                                                            readonly title: "Currency code";
+                                                                            readonly description: "EUR, GBP, USD, etc...";
+                                                                        };
+                                                                    }, {
+                                                                        readonly mode: {
+                                                                            readonly enum: readonly ["From column"];
+                                                                            readonly title: "Type";
+                                                                        };
+                                                                        readonly metricPrefix: {
+                                                                            readonly type: "boolean";
+                                                                            readonly title: "Use Metric Prefix";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly currencyCodeField: {
+                                                                            readonly type: "string";
+                                                                            readonly title: "Currency Field";
+                                                                            readonly description: "Column containing the currency code (EUR, GBP, USD, etc...)";
+                                                                        };
+                                                                    }];
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Metric Prefix"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display large numbers with metric prefixes (e.g. 1.2K)";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["UNIX Timestamp"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display unix timestamp as datetime";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Age"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display time difference between now and the value";
+                                                                };
+                                                                readonly params: {
+                                                                    readonly optional: true;
+                                                                    readonly type: {
+                                                                        readonly variant: {
+                                                                            readonly title: "Variant";
+                                                                            readonly description: "Short shows top two biggest units";
+                                                                            readonly enum: readonly ["short", "full"];
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Markdown", "MarkdownPopup"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display string as Markdown";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["JSON Diff", "Text Diff"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Compare JSON or plain text values from two columns";
+                                                                };
+                                                                readonly params: {
+                                                                    readonly type: {
+                                                                        readonly oldColumn: "string";
+                                                                        readonly newColumn: "string";
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["DoclingDocument"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Renders a Docling parsed document";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Logs"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Renders a log viewer for text data";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["HTML"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display string as sanitised HTML";
+                                                                };
+                                                                readonly params: {
+                                                                    readonly type: {
+                                                                        readonly noSanitize: {
+                                                                            readonly type: "boolean";
+                                                                            readonly title: "Do not sanitize HTML";
+                                                                            readonly description: "Leave unchecked if you understand the risks";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                        readonly allowedHTMLTags: {
+                                                                            readonly title: "Allowed HTML Tags";
+                                                                            readonly type: "string[]";
+                                                                            readonly allowedValues: string[];
+                                                                            readonly description: "List of allowed HTML tags. E.g.: div, p, html";
+                                                                            readonly optional: true;
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly enum: readonly ["Media"];
+                                                                    readonly title: "Format";
+                                                                    readonly description: "Display media (video/image/audio) from URL";
+                                                                };
+                                                                readonly params: {
+                                                                    readonly type: {
+                                                                        readonly contentType: {
+                                                                            readonly optional: true;
+                                                                            readonly title: "Content type";
+                                                                            readonly oneOfType: readonly [{
+                                                                                readonly mode: {
+                                                                                    readonly enum: readonly ["Auto"];
+                                                                                    readonly title: "Auto detect from URL and headers (default)";
+                                                                                };
+                                                                            }, {
+                                                                                readonly mode: {
+                                                                                    readonly enum: readonly ["Fixed"];
+                                                                                    readonly title: "Fixed";
+                                                                                };
+                                                                                readonly fixedContentType: {
+                                                                                    readonly type: "string";
+                                                                                    readonly title: "Fixed content type";
+                                                                                    readonly allowedValues: readonly ["image", "video", "audio"];
+                                                                                };
+                                                                            }, {
+                                                                                readonly mode: {
+                                                                                    readonly enum: readonly ["From column"];
+                                                                                    readonly title: "From column";
+                                                                                };
+                                                                                readonly contentTypeColumnName: {
+                                                                                    readonly title: "MIME column";
+                                                                                    readonly type: "string";
+                                                                                    readonly description: "Column that contains valid extension values (img, mp4, mp3, ...)";
+                                                                                };
+                                                                            }, {
+                                                                                readonly mode: {
+                                                                                    readonly enum: readonly ["From URL Extension"];
+                                                                                    readonly title: "From URL Extension (e.g. .png, .mp4)";
+                                                                                };
+                                                                            }];
+                                                                        };
+                                                                        readonly titleColumn: {
+                                                                            readonly optional: true;
+                                                                            readonly type: "string";
+                                                                            readonly title: "Title column";
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }];
+                                                        };
+                                                        readonly style: {
+                                                            readonly optional: true;
+                                                            readonly oneOf: readonly [{
+                                                                readonly type: {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Conditional"];
+                                                                    };
+                                                                    readonly column: {
+                                                                        readonly type: "string";
+                                                                        readonly optional: true;
+                                                                    };
+                                                                    readonly conditions: {
+                                                                        readonly arrayOf: {
+                                                                            readonly oneOf: readonly [{
+                                                                                readonly type: {
+                                                                                    readonly textColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly chipColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly cellColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly borderColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly operator: {
+                                                                                        readonly enum: readonly ["contains", "=", ">", ">=", "<", "<=", "!="];
+                                                                                    };
+                                                                                    readonly condition: "any";
+                                                                                };
+                                                                            }, {
+                                                                                readonly type: {
+                                                                                    readonly textColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly chipColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly cellColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly borderColor: {
+                                                                                        readonly type: "string";
+                                                                                        readonly optional: true;
+                                                                                    };
+                                                                                    readonly operator: {
+                                                                                        readonly enum: readonly ["in", "not in"];
+                                                                                    };
+                                                                                    readonly condition: "any[]";
+                                                                                };
+                                                                            }];
+                                                                        };
+                                                                    };
+                                                                    readonly defaultStyle: {
+                                                                        readonly optional: true;
+                                                                        readonly type: {
+                                                                            readonly textColor: {
+                                                                                readonly type: "string";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly chipColor: {
+                                                                                readonly type: "string";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly cellColor: {
+                                                                                readonly type: "string";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                            readonly borderColor: {
+                                                                                readonly type: "string";
+                                                                                readonly optional: true;
+                                                                            };
+                                                                        };
+                                                                    };
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Scale"];
+                                                                    };
+                                                                    readonly textColor: "string";
+                                                                    readonly minColor: "string";
+                                                                    readonly maxColor: "string";
+                                                                };
+                                                            }, {
+                                                                readonly type: {
+                                                                    readonly type: {
+                                                                        readonly enum: readonly ["Barchart"];
+                                                                    };
+                                                                    readonly barColor: "string";
+                                                                    readonly textColor: "string";
+                                                                };
+                                                            }];
+                                                        };
+                                                    };
+                                                };
+                                            };
+                                        };
+                                        readonly card: {
+                                            readonly optional: true;
+                                            readonly description: "Card view options";
+                                            readonly type: {
+                                                readonly avatarColumn: {
+                                                    readonly type: "string";
+                                                    readonly description: "Column name that contains url to an image to be shown as an avatar in card view.";
+                                                    readonly optional: true;
+                                                };
+                                                readonly headerColumn: {
+                                                    readonly optional: true;
+                                                    readonly type: "string";
+                                                    readonly description: "Column name that should be used as the header in card view.";
+                                                };
+                                                readonly subHeaderColumn: {
+                                                    readonly optional: true;
+                                                    readonly type: "string";
+                                                    readonly description: "Column name that should be used as the sub-header in card view.";
+                                                };
+                                                readonly visibleColumns: {
+                                                    readonly optional: true;
+                                                    readonly description: "Array of column names that should be visible in card view by default";
+                                                    readonly arrayOf: {
+                                                        readonly oneOf: readonly ["string", {
+                                                            readonly type: {
+                                                                readonly column: "string";
+                                                                readonly hideLabel: {
+                                                                    readonly type: "boolean";
+                                                                    readonly optional: true;
+                                                                };
+                                                            };
+                                                        }];
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "unknown";
+                };
+            };
+            readonly find_icons: {
+                readonly icon: "ImageSearch";
+                readonly mode: undefined;
+                readonly description: "Search for icons by name. Returns a list of icon names that match the search query.";
+                readonly schema: {
+                    readonly type: {
+                        readonly query: "string";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string[]";
+                };
+            };
+            readonly create_dashboards: {
+                readonly icon: "ViewCarousel";
+                readonly mode: "auto-approved-user-actionable";
+                readonly description: "Suggest Prostgles UI dashboards to visualize data for the specified task.";
+                readonly schema: {
+                    readonly type: {
+                        readonly prostglesWorkspaces: {
+                            readonly description: "Workspace to create. Must satisfy the typescript WorkspaceInsertModel type";
+                            readonly arrayOf: "any";
+                        };
+                    };
+                };
+                readonly outputSchema: "string";
+            };
+        };
+    };
+    handler: ProstglesMcpServerHandler;
+} | {
+    definition: {
+        readonly icon_path: "DatabaseOutline";
+        readonly label: "Database";
+        readonly description: "Tools to interact with your database";
+        readonly tools: {
+            readonly get_existing_tables_schema: {
+                readonly icon: "DatabaseEyeOutline";
+                readonly description: string;
+                readonly schema: {
+                    readonly type: {
+                        readonly tableNames: {
+                            readonly optional: true;
+                            readonly type: "string[]";
+                        };
+                        readonly tableNameRegex: {
+                            readonly optional: true;
+                            readonly type: "string";
+                            readonly description: "Regular expression to match table names. For example, 'user' will match tables with names like 'user', 'users', 'app_user', etc.";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+            readonly execute_readonly_sql: {
+                readonly icon: "DatabaseSearchOutline";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly description: "Executes a SQL query on the connected database in readonly mode (no data can be changed, the transaction is rolled back at the end).";
+                readonly schema: {
+                    readonly type: {
+                        readonly sql: {
+                            readonly type: "string";
+                            readonly description: "SQL query to execute";
+                        };
+                        readonly query_timeout: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                        };
+                        readonly query_params: {
+                            readonly optional: true;
+                            readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                            readonly oneOf: readonly ["any[]", {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            }];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly execute_sql: {
+                readonly icon: "DatabaseEditOutline";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                    readonly destructiveHint: true;
+                };
+                readonly description: "Executes a SQL query on the connected database in commit mode (data can be changed, the transaction committed at the end).";
+                readonly schema: {
+                    readonly type: {
+                        readonly sql: {
+                            readonly type: "string";
+                            readonly description: "SQL query to execute";
+                        };
+                        readonly query_timeout: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Maximum time in milliseconds the query will be allowed to run. Defaults to 30000.";
+                        };
+                        readonly query_params: {
+                            readonly optional: true;
+                            readonly description: "Query parameters to use in the SQL query. Must satisfy the query schema. Supports index based ($1, $2, etc.) and named parameters (${paramName}).";
+                            readonly oneOf: readonly ["any[]", {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            }];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly count: {
+                readonly icon: "DatabaseEyeOutline";
+                readonly description: "Counts rows in a table that satisfy a filter.";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly filter: {
+                            readonly optional: true;
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    };
+                };
+                readonly outputSchema: "number";
+            };
+            readonly find: {
+                readonly icon: "TableSearch";
+                readonly description: "Selects rows from a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: true;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                            readonly optional: true;
+                        };
+                        readonly select: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                        };
+                        readonly orderBy: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly arrayOfType: {
+                                    readonly key: "string";
+                                    readonly asc: {
+                                        readonly enum: readonly [true, false];
+                                    };
+                                    readonly nulls: {
+                                        readonly enum: readonly ["first", "last"];
+                                        readonly optional: true;
+                                    };
+                                };
+                            }, {
+                                readonly type: {
+                                    readonly key: "string";
+                                    readonly asc: {
+                                        readonly enum: readonly [true, false];
+                                    };
+                                    readonly nulls: {
+                                        readonly enum: readonly ["first", "last"];
+                                        readonly optional: true;
+                                    };
+                                };
+                            }];
+                        };
+                        readonly limit: {
+                            readonly optional: true;
+                            readonly description: "Defaults to 10";
+                            readonly type: "integer";
+                        };
+                        readonly offset: {
+                            readonly optional: true;
+                            readonly type: "integer";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                };
+            };
+            readonly insert: {
+                readonly icon: "TablePlus";
+                readonly description: "Inserts a row into a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly onConflict: {
+                            readonly enum: readonly ["DoNothing", "DoUpdate"];
+                            readonly optional: true;
+                            readonly description: string;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly optional: true;
+                    readonly description: "Inserted row returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                    readonly record: {
+                        readonly values: "any";
+                    };
+                };
+            };
+            readonly insertMany: {
+                readonly icon: "TablePlus";
+                readonly description: "Inserts rows into a table.";
+                readonly annotations: {
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly tableName: "string";
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly arrayOf: {
+                                readonly record: {
+                                    readonly values: "any";
+                                };
+                            };
+                        };
+                        readonly onConflict: {
+                            readonly enum: readonly ["DoNothing", "DoUpdate"];
+                            readonly optional: true;
+                            readonly description: string;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for newly inserted data. Nothing will be returned otherwise";
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly arrayOf: {
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    };
+                    readonly optional: true;
+                    readonly description: "Inserted rows returned based on the returning fields. Nothing will be returned if returning is not provided.";
+                };
+            };
+            readonly update: {
+                readonly icon: "TableEdit";
+                readonly description: "Updates rows in a table.";
+                readonly annotations: {
+                    readonly destructiveHint: true;
+                    readonly readOnlyHint: false;
+                };
+                readonly schema: {
+                    readonly type: {
+                        readonly data: {
+                            readonly description: "Data to insert into the table. Must satisfy the table schema.";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly removeDisallowedFields: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "Whether to remove fields that are not allowed to be updated instead of throwing an error.";
+                        };
+                        readonly multi: {
+                            readonly description: "true by default. When set to false the update will throw an error if more than one row is updated (but the update will commit).";
+                            readonly type: "boolean";
+                            readonly optional: true;
+                        };
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for updated data. Nothing will be returned otherwise";
+                        };
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly tableName: "string";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly optional: true;
+                    readonly oneOf: readonly [{
+                        readonly record: {
+                            readonly values: "any";
+                        };
+                    }, {
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    }];
+                };
+            };
+            readonly delete: {
+                readonly icon: "TableRemove";
+                readonly annotations: {
+                    readonly destructiveHint: true;
+                    readonly readOnlyHint: false;
+                };
+                readonly description: "Deletes rows from a table.";
+                readonly schema: {
+                    readonly type: {
+                        readonly returning: {
+                            readonly optional: true;
+                            readonly oneOf: readonly [{
+                                readonly enum: readonly ["*"];
+                            }, {
+                                readonly description: "Fields to select. Must satisfy the table schema. Example: { id: 1, name: 1 } or { password: 0 }";
+                                readonly record: {
+                                    readonly values: {
+                                        readonly enum: readonly [1, 0];
+                                    };
+                                };
+                            }];
+                            readonly description: "Fields to return for the deleted rows. Nothing will be returned otherwise";
+                        };
+                        readonly filter: {
+                            readonly description: "Row filter. Must satisfy the table schema. Example filters: { $or: [{ id: 1 }, { name: { $in: ['John'] } }] }";
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                        readonly tableName: "string";
+                    };
+                };
+                readonly outputSchema: {
+                    readonly oneOf: readonly [{
+                        readonly arrayOf: {
+                            readonly record: {
+                                readonly values: "any";
+                            };
+                        };
+                    }, {
+                        readonly enum: readonly [undefined];
+                    }];
+                };
+            };
+        };
+        readonly config_schema: undefined;
+    };
+    handler: ProstglesMcpServerHandler;
+} | {
+    definition: {
+        readonly icon_path: "TextBoxSearchOutline";
+        readonly label: "Documents";
+        readonly description: "Convert documents to text and extract information from them";
+        readonly tools: {
+            readonly get_document_text: {
+                readonly mode: undefined;
+                readonly description: "Converts documents/images into structured data. Supported formats: txt, pdf, docx, pptx, jpg, png, and more. Powered by [docling](https://www.docling.ai/).";
+                readonly schema: {
+                    readonly type: {
+                        readonly to_format: {
+                            readonly optional: true;
+                            readonly description: "Defaults to \"md\". Convert the document to a specific format.";
+                            readonly enum: readonly ["md", "json", "yaml", "html", "html_split_page", "text", "doctags"];
+                        };
+                        readonly from_formats: {
+                            readonly optional: true;
+                            readonly type: "string[]";
+                            readonly allowedValues: readonly ["docx", "pptx", "html", "image", "pdf", "asciidoc", "md", "csv", "xlsx", "xml_uspto", "xml_jats", "xml_xbrl", "mets_gbs", "json_docling", "audio", "vtt", "latex"];
+                        };
+                        readonly image_export_mode: {
+                            readonly optional: true;
+                            readonly enum: readonly ["placeholder", "embedded", "referenced"];
+                            readonly description: "Image export mode for the document (in case of JSON, Markdown or HTML). Allowed values: placeholder, embedded, referenced. Optional, defaults to Embedded.";
+                        };
+                        readonly page_range: {
+                            readonly tuple: readonly ["number", "number"];
+                            readonly optional: true;
+                            readonly description: "Only convert a range of pages. The page number starts at 1. For example, [1, 3] will convert only the first and third pages of the document.";
+                        };
+                        readonly do_ocr: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, the bitmap content will be processed using OCR. Boolean. Optional, defaults to true";
+                        };
+                        readonly force_ocr: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, replace existing text with OCR-generated text over content. Boolean. Optional, defaults to false.";
+                        };
+                        readonly ocr_engine: {
+                            readonly enum: readonly ["auto", "easyocr", "ocrmac", "rapidocr", "tesserocr", "tesseract"];
+                            readonly optional: true;
+                            readonly description: "The OCR engine to use. String. Allowed values: auto, easyocr, ocrmac, rapidocr, tesserocr, tesseract. Optional, defaults to easyocr.";
+                        };
+                        readonly ocr_lang: {
+                            readonly type: "string[]";
+                            readonly optional: true;
+                            readonly description: "List of languages used by the OCR engine. Note that each OCR engine has different values for the language names. String or list of strings. Optional, defaults to empty.";
+                        };
+                        readonly document_timeout: {
+                            readonly optional: true;
+                            readonly type: "number";
+                            readonly description: "The timeout for processing each document, in seconds.";
+                        };
+                        readonly pdf_backend: {
+                            readonly enum: readonly ["pypdfium2", "docling_parse", "dlparse_v1", "dlparse_v2", "dlparse_v4"];
+                            readonly optional: true;
+                            readonly description: "The PDF backend to use. String. Allowed values: pypdfium2, docling_parse, dlparse_v1, dlparse_v2, dlparse_v4. Optional, defaults to docling_parse.";
+                        };
+                        readonly table_mode: {
+                            readonly enum: readonly ["fast", "accurate"];
+                            readonly optional: true;
+                            readonly description: "Mode to use for table structure, String. Allowed values: fast, accurate. Optional, defaults to accurate.";
+                        };
+                        readonly do_table_structure: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, the table structure will be extracted. Boolean. Optional, defaults to true.";
+                        };
+                        readonly include_images: {
+                            readonly type: "boolean";
+                            readonly optional: true;
+                            readonly description: "If enabled, images will be extracted from the document. Boolean. Optional, defaults to true.";
+                        };
+                        readonly md_page_break_placeholder: {
+                            readonly type: "string";
+                            readonly optional: true;
+                            readonly description: "Add this placeholder between pages in the markdown output.";
+                        };
+                        readonly images_scale: {
+                            readonly type: "number";
+                            readonly optional: true;
+                            readonly description: "Scale factor for images. Float. Optional, defaults to 2.0.";
+                        };
+                        readonly fileAsBase64: "string";
+                        readonly contentType: {
+                            readonly enum: readonly ["application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "application/vnd.openxmlformats-officedocument.presentationml.presentation", "image/png", "image/jpeg", "image/tiff", "image/bmp", "image/webp"];
+                        };
+                    };
+                };
+                readonly outputSchema: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly config_schema: undefined;
+    };
+    handler: ProstglesMcpServerHandler;
+} | undefined;
+//# sourceMappingURL=ProstglesMCPServers.d.ts.map