langflow-mcp-server 3.1.1 → 4.12.2

package/dist/mcp/tools.js

@@ -414,10 +414,13 @@ Parameters:
 - flow_id_or_name (required, string): Flow identifier (UUID) or flow name (case-sensitive)
 - input_request (required, object): Execution configuration containing:
   - input_value (optional, string): Primary input data for the flow (e.g., user message, data to process)
+  - output_component (optional, string): Specific output component to return
   - output_type (optional, string): Expected output format (e.g., "chat", "text", "json")
   - input_type (optional, string): Type of input being provided (e.g., "chat", "text", "json")
+  - session_id (optional, string): Session ID for conversation continuity
   - tweaks (optional, object): Component-specific parameter overrides (key: component_id, value: parameter object)
-- stream (optional, boolean, default: false): Enable streaming mode for real-time token-by-token responses
+- context (optional, object): Request context passed alongside the input request
+- stream (optional, boolean, default: false): Streaming is currently rejected by this MCP client because streamed responses are not JSON serializable
 
 Returns: RunResponse object containing:
 - outputs (array): Flow execution results from output components
@@ -427,13 +430,13 @@ Returns: RunResponse object containing:
 Usage Examples:
 1. Simple execution: { flow_id_or_name: "my-chatbot", input_request: { input_value: "Hello" } }
 2. With output type: { flow_id_or_name: "data-processor", input_request: { input_value: "data", output_type: "json" } }
-3. With streaming: { flow_id_or_name: "llm-chat", input_request: { input_value: "Explain AI" }, stream: true }
+3. With context: { flow_id_or_name: "llm-chat", input_request: { input_value: "Explain AI" }, context: { tenant: "acme" } }
 4. With tweaks: { flow_id_or_name: "flow-uuid", input_request: { input_value: "test", tweaks: { "component-id": { temperature: 0.7 } } } }
 
 Best Practices:
 - Use flow ID (UUID) for production; names may change or conflict
 - Build flow first with build_flow to ensure it's valid before execution
-- Use streaming for LLM-based flows to provide real-time user feedback
+- Leave stream false; this MCP client currently returns JSON tool responses only
 - Cache session_id for multi-turn conversations to maintain context
 - Set appropriate timeout values for long-running flows
 - Test flows with various inputs before production deployment
@@ -468,6 +471,10 @@ Related Tools:
                             type: 'string',
                             description: 'Input value for the flow'
                         },
+                        output_component: {
+                            type: 'string',
+                            description: 'Specific output component to return'
+                        },
                         output_type: {
                             type: 'string',
                             description: 'Expected output type'
@@ -476,15 +483,23 @@ Related Tools:
                             type: 'string',
                             description: 'Type of input being provided'
                         },
+                        session_id: {
+                            type: 'string',
+                            description: 'Session ID for conversation continuity'
+                        },
                         tweaks: {
                             type: 'object',
                             description: 'Optional parameter tweaks'
                         }
                     }
                 },
+                context: {
+                    type: 'object',
+                    description: 'Request context passed alongside the input request'
+                },
                 stream: {
                     type: 'boolean',
-                    description: 'Enable streaming mode (default: false)'
+                    description: 'Streaming is currently rejected by this MCP client'
                 }
             },
             required: ['flow_id_or_name', 'input_request']
@@ -1221,6 +1236,53 @@ Related Tools:
             openWorldHint: true
         }
     },
+    {
+        name: 'build_public_flow',
+        description: 'Build a public flow without authentication using Langflow 1.11.x public-build semantics.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Public flow ID (UUID)' },
+                inputs: {
+                    type: ['object', 'null'],
+                    description: 'Optional single input request with components, input_value, session, and type'
+                },
+                files: { type: ['array', 'null'], items: { type: 'string' }, description: 'Optional flow-scoped file paths' },
+                stop_component_id: { type: ['string', 'null'], description: 'Optional component to stop at' },
+                start_component_id: { type: ['string', 'null'], description: 'Optional component to start from' },
+                log_builds: { type: ['boolean', 'null'], description: 'Whether to log the public build' },
+                flow_name: { type: ['string', 'null'], description: 'Optional flow name override' },
+                event_delivery: { type: 'string', enum: ['polling', 'streaming', 'direct'], description: 'Build event delivery mode' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_public_build_events',
+        description: 'Get events for a public flow build job, including streaming event payloads.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Public build job ID' },
+                event_delivery: { type: 'string', enum: ['polling', 'streaming', 'direct'], description: 'Event delivery mode' }
+            },
+            required: ['job_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'cancel_public_build',
+        description: 'Cancel a public flow build job.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Public build job ID' }
+            },
+            required: ['job_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
     {
         name: 'list_knowledge_bases',
         description: `List all knowledge bases for Retrieval-Augmented Generation (RAG) workflows.
@@ -1641,7 +1703,7 @@ Related Tools:
     },
     {
         name: 'run_flow_advanced',
-        description: 'Advanced flow execution with full parameter control including tweaks, input/output types, session management, and streaming. Supports both flow UUID and flow name.',
+        description: 'Advanced flow execution using Langflow 1.11.x input/output request arrays, tweaks, sessions, and streaming.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -1649,28 +1711,21 @@ Related Tools:
                     type: 'string',
                     description: 'Flow ID (UUID) or flow name to execute'
                 },
-                input_value: {
-                    type: 'string',
-                    description: 'Input value for the flow'
-                },
-                input_type: {
-                    type: 'string',
-                    description: 'Type of input (e.g., "chat", "text")'
-                },
-                output_type: {
-                    type: 'string',
-                    description: 'Expected output type (e.g., "chat", "text", "json")'
+                inputs: {
+                    type: ['array', 'null'],
+                    description: 'InputValueRequest array with optional components, input_value, session, and type'
                 },
-                output_component: {
-                    type: 'string',
-                    description: 'Specific output component to retrieve results from'
+                outputs: {
+                    type: ['array', 'null'],
+                    items: { type: 'string' },
+                    description: 'Optional output component names or IDs'
                 },
                 tweaks: {
-                    type: 'object',
+                    type: ['object', 'null'],
                     description: 'Component-specific parameter overrides'
                 },
                 session_id: {
-                    type: 'string',
+                    type: ['string', 'null'],
                     description: 'Session ID for conversation continuity'
                 },
                 user_id: {
@@ -1725,9 +1780,13 @@ Related Tools:
                     type: 'string',
                     description: 'Session ID for conversation continuity (required)'
                 },
+                context: {
+                    type: 'object',
+                    description: 'Request context passed alongside the input request'
+                },
                 stream: {
                     type: 'boolean',
-                    description: 'Enable streaming mode (default: false)'
+                    description: 'Streaming is currently rejected by this MCP client'
                 }
             },
             required: ['flow_id_or_name', 'session_id']
@@ -2072,31 +2131,6 @@ Related Tools:
             openWorldHint: true
         }
     },
-    {
-        name: 'get_vertex',
-        description: '⚠️ DEPRECATED: This endpoint is deprecated in Langflow API 1.6.4 and will be removed in a future version. Use "build_flow" tool instead to build specific components, or "get_flow" to retrieve flow structure.\n\nGet detailed information about a specific vertex (component) in a flow. Retrieves vertex configuration, state, and metadata. Essential for inspecting individual component details, debugging component issues, and understanding flow structure at the component level.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                flow_id: {
-                    type: 'string',
-                    format: 'uuid',
-                    description: 'Flow ID (UUID) containing the vertex'
-                },
-                vertex_id: {
-                    type: 'string',
-                    description: 'Vertex ID to retrieve details for'
-                }
-            },
-            required: ['flow_id', 'vertex_id']
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true
-        }
-    },
     {
         name: 'stream_vertex_build',
         description: '⚠️ DEPRECATED: This endpoint is deprecated in Langflow API 1.6.4 and will be removed in a future version. Use "get_build_status" tool with event_delivery="streaming" to monitor build progress.\n\nStream real-time build events for a specific vertex. Provides live updates during vertex build process using server-sent events (SSE). Essential for monitoring long-running component builds, debugging build failures in real-time, and providing live build status to users.',
@@ -2172,27 +2206,6 @@ Related Tools:
             openWorldHint: true
         }
     },
-    {
-        name: 'get_user',
-        description: 'Get details about a specific user by ID. Returns user profile information including username, email, active status, and profile picture.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                user_id: {
-                    type: 'string',
-                    format: 'uuid',
-                    description: 'User ID (UUID)'
-                }
-            },
-            required: ['user_id']
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true
-        }
-    },
     {
         name: 'update_user',
         description: 'Update user profile information. Can modify username, password, or profile image. Returns updated user object.',
@@ -2306,20 +2319,6 @@ Related Tools:
             openWorldHint: true
         }
     },
-    {
-        name: 'list_custom_components',
-        description: 'List all custom components created by the user. Returns array of custom component objects with code, name, description, and return type.',
-        inputSchema: {
-            type: 'object',
-            properties: {}
-        },
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: true
-        }
-    },
     {
         name: 'create_custom_component',
         description: 'Create a new custom component with Python code. Requires component code, name, and optional description and return_type. Returns created component object.',
@@ -2559,7 +2558,7 @@ Related Tools:
     },
     {
         name: 'upload_knowledge_base',
-        description: 'Upload file to create or update a knowledge base for RAG. Provide knowledge base name, base64-encoded file content, and filename.',
+        description: 'Ingest a file into an existing knowledge base for RAG. Provide knowledge base name, base64-encoded file content, and filename.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -2631,6 +2630,1922 @@ Related Tools:
             idempotentHint: true,
             openWorldHint: true
         }
+    },
+    {
+        name: 'replace_flow',
+        description: 'Replace an entire flow (PUT) with new content. Overwrites name, description, data, and folder for the given flow ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID) to replace' },
+                name: { type: 'string', description: 'New flow name' },
+                description: { type: 'string', description: 'Optional flow description' },
+                data: { type: 'object', description: 'Optional flow data/configuration' },
+                folder_id: { type: 'string', description: 'Optional folder ID (UUID)' }
+            },
+            required: ['flow_id', 'name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'expand_flows',
+        description: 'Expand flows by resolving component references into full flow definitions. Pass the expansion request payload as the body object.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                body: { type: 'object', description: 'Flow expansion request payload' }
+            },
+            required: ['body']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_flow_events',
+        description: 'Get the event stream/history for a flow. Optionally filter to events since a given cursor/timestamp.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                since: { type: 'number', description: 'Optional cursor: only events since this value' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_flow_event',
+        description: 'Create a new event for a flow (e.g. deployment or lifecycle event).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                type: { type: 'string', description: 'Event type' },
+                summary: { type: 'string', description: 'Optional event summary' }
+            },
+            required: ['flow_id', 'type']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'list_flow_versions',
+        description: 'List saved versions of a flow with optional pagination and deployment provider filter.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                limit: { type: 'number', description: 'Max number of versions to return' },
+                offset: { type: 'number', description: 'Number of versions to skip' },
+                deployment_provider_id: { type: 'string', description: 'Optional deployment provider filter' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_flow_version',
+        description: 'Create a new saved version (snapshot) of a flow. Optionally provide a body with version metadata.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                body: { type: 'object', description: 'Optional version creation payload' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_flow_version',
+        description: 'Get a specific saved version of a flow by version ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                version_id: { type: 'string', description: 'Version ID' }
+            },
+            required: ['flow_id', 'version_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_flow_version',
+        description: 'Delete a specific saved version of a flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                version_id: { type: 'string', description: 'Version ID to delete' }
+            },
+            required: ['flow_id', 'version_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'activate_flow_version',
+        description: 'Activate a specific saved version of a flow, making it the current version. Optionally save the current state as a draft first.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID (UUID)' },
+                version_id: { type: 'string', description: 'Version ID to activate' },
+                save_draft: { type: 'boolean', description: 'Save current state as draft before activating' }
+            },
+            required: ['flow_id', 'version_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'detect_variables',
+        description: 'Detect global variables referenced by one or more flow versions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_version_ids: { type: 'array', items: { type: 'string' }, description: 'Flow version IDs to scan' }
+            },
+            required: ['flow_version_ids']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'save_store_api_key',
+        description: 'Save the Langflow Store API key for the current user so store operations are authenticated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                api_key: { type: 'string', description: 'Langflow Store API key' }
+            },
+            required: ['api_key']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_custom_component',
+        description: 'Update a custom component template field, recomputing the frontend node based on the provided code and field changes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                code: { type: 'string', description: 'Custom component source code' },
+                field: { type: 'string', description: 'Template field being updated' },
+                template: { type: 'object', description: 'Current component template' },
+                field_value: { type: ['string', 'number', 'boolean', 'object', 'array', 'null'], description: 'New value for the field (any JSON type)' },
+                frontend_node: { type: 'object', description: 'Optional current frontend node definition' },
+                tool_mode: { type: 'boolean', description: 'Optional tool-mode flag' }
+            },
+            required: ['code', 'field', 'template']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'create_store_component',
+        description: 'Publish a new component to the Langflow Store.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Component name' },
+                description: { type: 'string', description: 'Optional component description' },
+                data: { type: 'object', description: 'Component data/definition' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags' },
+                is_component: { type: 'boolean', description: 'Whether this is a component (vs a flow)' },
+                parent: { type: 'string', description: 'Optional parent component ID' },
+                last_tested_version: { type: 'string', description: 'Optional last tested Langflow version' },
+                private: { type: 'boolean', description: 'Whether the component is private' }
+            },
+            required: ['name', 'data']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'like_store_component',
+        description: 'Like (or toggle like on) a Langflow Store component.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                component_id: { type: 'string', description: 'Store component ID' }
+            },
+            required: ['component_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'create_response',
+        description: 'Create a response via the OpenAI-compatible /responses endpoint using a model and input.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model: { type: 'string', description: 'Model identifier' },
+                input: { type: 'string', description: 'Input text' },
+                stream: { type: 'boolean', description: 'Stream the response' },
+                background: { type: 'boolean', description: 'Run in background' },
+                previous_response_id: { type: 'string', description: 'Optional previous response ID for chaining' },
+                include: { type: 'array', items: { type: 'string' }, description: 'Optional include fields' },
+                tools: { type: 'array', items: { type: 'object' }, description: 'Optional tool definitions' }
+            },
+            required: ['model', 'input']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_session',
+        description: 'Get the current authenticated session information.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_user',
+        description: 'Create a new Langflow user account.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                username: { type: 'string', description: 'Username' },
+                password: { type: 'string', description: 'Password' },
+                optins: { type: 'object', description: 'Optional opt-in preferences' }
+            },
+            required: ['username', 'password']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_webhook_events',
+        description: 'Get webhook events for a flow by ID or name. Optionally filter by user ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id_or_name: { type: 'string', description: 'Flow ID (UUID) or name' },
+                user_id: { type: 'string', description: 'Optional user ID filter' }
+            },
+            required: ['flow_id_or_name']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_health_check',
+        description: 'Get the detailed health check report from the Langflow server root /health_check endpoint.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_files_v2',
+        description: 'List user-scoped files via the /api/v2/files endpoint.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'upload_file_v2',
+        description: 'Upload a user-scoped file via /api/v2/files. Provide base64 file content and filename; optionally append or mark ephemeral.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_content: { type: 'string', description: 'Base64 encoded file content' },
+                file_name: { type: 'string', description: 'Name of the file to upload' },
+                append: { type: 'boolean', description: 'Append to an existing file' },
+                ephemeral: { type: 'boolean', description: 'Mark the file as ephemeral' }
+            },
+            required: ['file_content', 'file_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_file_v2',
+        description: 'Get a user-scoped file by ID via /api/v2/files. Optionally return the file content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: { type: 'string', description: 'File ID' },
+                return_content: { type: 'boolean', description: 'Return file content in the response' }
+            },
+            required: ['file_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'rename_file_v2',
+        description: 'Rename a user-scoped file via /api/v2/files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: { type: 'string', description: 'File ID' },
+                name: { type: 'string', description: 'New file name' }
+            },
+            required: ['file_id', 'name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_file_v2',
+        description: 'Delete a user-scoped file by ID via /api/v2/files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_id: { type: 'string', description: 'File ID to delete' }
+            },
+            required: ['file_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_all_files_v2',
+        description: 'Delete ALL user-scoped files via /api/v2/files. This is irreversible.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'batch_download_files_v2',
+        description: 'Batch download multiple user-scoped files via /api/v2/files by their IDs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_ids: { type: 'array', items: { type: 'string' }, description: 'File IDs to download' }
+            },
+            required: ['file_ids']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'batch_delete_files_v2',
+        description: 'Batch delete multiple user-scoped files via /api/v2/files by their IDs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_ids: { type: 'array', items: { type: 'string' }, description: 'File IDs to delete' }
+            },
+            required: ['file_ids']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_knowledge_bases_detailed',
+        description: 'List knowledge bases with detailed metadata (embedding config, chunk counts, etc.).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_knowledge_base',
+        description: 'Create a new knowledge base with an embedding provider/model and optional column configuration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Knowledge base name' },
+                embedding_provider: { type: 'string', description: 'Embedding provider' },
+                embedding_model: { type: 'string', description: 'Embedding model' },
+                column_config: { type: 'array', items: { type: 'object' }, description: 'Optional column configuration' }
+            },
+            required: ['name', 'embedding_provider', 'embedding_model']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'preview_knowledge_base_chunks',
+        description: 'Preview how a file would be chunked for knowledge base ingestion. Provide base64 file content, filename, and optional chunking params.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_content: { type: 'string', description: 'Base64 encoded file content' },
+                file_name: { type: 'string', description: 'Name of the file' },
+                params: { type: 'object', description: 'Optional chunking parameters' }
+            },
+            required: ['file_content', 'file_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'list_knowledge_base_chunks',
+        description: 'List chunks stored in a knowledge base with optional pagination and search.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                page: { type: 'number', description: 'Page number' },
+                limit: { type: 'number', description: 'Chunks per page' },
+                search: { type: 'string', description: 'Optional search query' }
+            },
+            required: ['kb_name']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'ingest_knowledge_base',
+        description: 'Ingest a file into an existing knowledge base. Provide base64 file content, filename, and optional ingestion params.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                file_content: { type: 'string', description: 'Base64 encoded file content' },
+                file_name: { type: 'string', description: 'Name of the file' },
+                params: { type: 'object', description: 'Optional ingestion parameters' }
+            },
+            required: ['kb_name', 'file_content', 'file_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'cancel_knowledge_base_ingest',
+        description: 'Cancel an in-progress knowledge base ingestion job.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' }
+            },
+            required: ['kb_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_monitor_message',
+        description: 'Update a stored monitor message (text, sender, session, files, or properties).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                message_id: { type: 'string', description: 'Message ID' },
+                text: { type: 'string', description: 'Updated message text' },
+                sender: { type: 'string', description: 'Updated sender' },
+                sender_name: { type: 'string', description: 'Updated sender name' },
+                session_id: { type: 'string', description: 'Updated session ID' },
+                files: { type: 'array', items: { type: 'string' }, description: 'Updated file references' },
+                properties: { type: 'object', description: 'Updated message properties' }
+            },
+            required: ['message_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'delete_monitor_session_messages',
+        description: 'Delete all monitor messages for a given session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' }
+            },
+            required: ['session_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_monitor_sessions',
+        description: 'Delete multiple monitor sessions by their IDs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_ids: { type: 'array', items: { type: 'string' }, description: 'Session IDs to delete' }
+            },
+            required: ['session_ids']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_shared_messages',
+        description: 'Get shared (playground) messages for a source flow, optionally filtered by session and ordered.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source_flow_id: { type: 'string', description: 'Source flow ID' },
+                session_id: { type: 'string', description: 'Optional session ID filter' },
+                order_by: { type: 'string', description: 'Optional order-by field' }
+            },
+            required: ['source_flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_shared_sessions',
+        description: 'Get the list of shared session IDs for a source flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source_flow_id: { type: 'string', description: 'Source flow ID' }
+            },
+            required: ['source_flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'update_shared_message',
+        description: 'Update a shared (playground) message for a source flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                message_id: { type: 'string', description: 'Message ID' },
+                source_flow_id: { type: 'string', description: 'Source flow ID' },
+                text: { type: 'string', description: 'Updated message text' },
+                sender: { type: 'string', description: 'Updated sender' },
+                sender_name: { type: 'string', description: 'Updated sender name' },
+                session_id: { type: 'string', description: 'Updated session ID' },
+                files: { type: 'array', items: { type: 'string' }, description: 'Updated file references' },
+                properties: { type: 'object', description: 'Updated message properties' }
+            },
+            required: ['message_id', 'source_flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'migrate_shared_session',
+        description: 'Migrate a shared session to a new session ID within a source flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Existing session ID' },
+                new_session_id: { type: 'string', description: 'New session ID' },
+                source_flow_id: { type: 'string', description: 'Source flow ID' }
+            },
+            required: ['session_id', 'new_session_id', 'source_flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'delete_shared_session',
+        description: 'Delete a shared session within a source flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID to delete' },
+                source_flow_id: { type: 'string', description: 'Source flow ID' }
+            },
+            required: ['session_id', 'source_flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_traces',
+        description: 'List execution traces with optional filters (flow, session, status, query, time range) and pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Optional flow ID filter' },
+                session_id: { type: 'string', description: 'Optional session ID filter' },
+                status: { type: 'string', description: 'Optional status filter' },
+                query: { type: 'string', description: 'Optional search query' },
+                start_time: { type: 'string', description: 'Optional start time (ISO)' },
+                end_time: { type: 'string', description: 'Optional end time (ISO)' },
+                page: { type: 'number', description: 'Page number' },
+                size: { type: 'number', description: 'Page size (max 100)' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_traces',
+        description: 'Delete all traces associated with a flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_trace',
+        description: 'Get a single execution trace by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                trace_id: { type: 'string', description: 'Trace ID' }
+            },
+            required: ['trace_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_trace',
+        description: 'Delete a single execution trace by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                trace_id: { type: 'string', description: 'Trace ID to delete' }
+            },
+            required: ['trace_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_models',
+        description: 'List available models with optional filters (provider, name, type, capabilities, search).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                provider: { type: 'string', description: 'Filter by provider' },
+                model_name: { type: 'string', description: 'Filter by model name' },
+                model_type: { type: 'string', description: 'Filter by model type' },
+                include_unsupported: { type: 'boolean', description: 'Include unsupported models' },
+                include_deprecated: { type: 'boolean', description: 'Include deprecated models' },
+                tool_calling: { type: 'boolean', description: 'Filter to tool-calling models' },
+                reasoning: { type: 'boolean', description: 'Filter to reasoning models' },
+                search: { type: 'string', description: 'Search query' },
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_model_providers',
+        description: 'List all known model providers.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_enabled_providers',
+        description: 'List enabled model providers, optionally restricted to a given set of provider names.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                providers: { type: 'array', items: { type: 'string' }, description: 'Optional provider names to check' },
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_enabled_models',
+        description: 'List enabled models, optionally restricted to a given set of model names.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_names: { type: 'array', items: { type: 'string' }, description: 'Optional model names to check' },
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'set_enabled_models',
+        description: 'Enable or disable specific models by provider and model ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                models: {
+                    type: 'array',
+                    description: 'Array of model status updates',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            provider: { type: 'string', description: 'Provider' },
+                            model_id: { type: 'string', description: 'Model ID' },
+                            enabled: { type: 'boolean', description: 'Enabled flag' }
+                        },
+                        required: ['provider', 'model_id', 'enabled']
+                    }
+                }
+            },
+            required: ['models']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_default_model',
+        description: 'Get the default model for a given model type.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_type: { type: 'string', description: 'Model type' }
+            },
+            required: ['model_type']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'set_default_model',
+        description: 'Set the default model (provider + model name) for a given model type.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                provider: { type: 'string', description: 'Provider' },
+                model_name: { type: 'string', description: 'Model name' },
+                model_type: { type: 'string', description: 'Model type' }
+            },
+            required: ['provider', 'model_name', 'model_type']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'delete_default_model',
+        description: 'Delete (clear) the default model for a given model type.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                model_type: { type: 'string', description: 'Model type' }
+            },
+            required: ['model_type']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_provider_variable_mapping',
+        description: 'Get the mapping between model providers and their required global variables.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'validate_model_provider',
+        description: 'Validate a model provider configuration with the provided variables (e.g. API keys).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                provider: { type: 'string', description: 'Provider to validate' },
+                variables: { type: 'object', description: 'Provider variables (e.g. API keys)' }
+            },
+            required: ['provider', 'variables']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_language_model_options',
+        description: 'Get available language (LLM) model options.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_embedding_model_options',
+        description: 'Get available embedding model options.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'agentic_assist',
+        description: 'Request agentic assistance for building or editing a flow component.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' },
+                input_value: { type: ['string', 'null'], description: 'User input/instruction (server-configured limit)' },
+                iterations_limit: { type: ['number', 'null'], description: 'Maximum assistant iterations (1-200)' },
+                session_id: { type: ['string', 'null'], description: 'Optional session ID' },
+                component_id: { type: ['string', 'null'], description: 'Optional target component ID' },
+                field_name: { type: ['string', 'null'], description: 'Optional target field name' },
+                model_name: { type: ['string', 'null'], description: 'Optional model name' },
+                provider: { type: ['string', 'null'], description: 'Optional provider' },
+                history_limit: { type: ['number', 'null'], description: 'Optional assistant history limit (0-100)' },
+                max_retries: { type: ['number', 'null'], description: 'Optional max retries (1-5)' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'agentic_assist_stream',
+        description: 'Request streaming agentic assistance for building or editing a flow component.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' },
+                input_value: { type: ['string', 'null'], description: 'User input/instruction (server-configured limit)' },
+                iterations_limit: { type: ['number', 'null'], description: 'Maximum assistant iterations (1-200)' },
+                max_retries: { type: ['number', 'null'], description: 'Maximum retries (1-5)' },
+                session_id: { type: ['string', 'null'], description: 'Optional session ID' },
+                component_id: { type: ['string', 'null'], description: 'Optional target component ID' },
+                field_name: { type: ['string', 'null'], description: 'Optional target field name' },
+                model_name: { type: ['string', 'null'], description: 'Optional model name' },
+                provider: { type: ['string', 'null'], description: 'Optional provider' },
+                history_limit: { type: ['number', 'null'], description: 'Optional assistant history limit (0-100)' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'agentic_check_config',
+        description: 'Check whether the agentic assistant is configured and available.',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'agentic_execute',
+        description: 'Execute an agentic assistant flow by name with the given assist request fields.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_name: { type: 'string', description: 'Agentic flow name to execute' },
+                flow_id: { type: 'string', description: 'Flow ID' },
+                input_value: { type: ['string', 'null'], description: 'User input/instruction (server-configured limit)' },
+                iterations_limit: { type: ['number', 'null'], description: 'Maximum assistant iterations (1-200)' },
+                session_id: { type: ['string', 'null'], description: 'Optional session ID' },
+                component_id: { type: ['string', 'null'], description: 'Optional target component ID' },
+                field_name: { type: ['string', 'null'], description: 'Optional target field name' },
+                model_name: { type: ['string', 'null'], description: 'Optional model name' },
+                provider: { type: ['string', 'null'], description: 'Optional provider' },
+                history_limit: { type: ['number', 'null'], description: 'Optional assistant history limit (0-100)' },
+                max_retries: { type: ['number', 'null'], description: 'Optional max retries (1-5)' }
+            },
+            required: ['flow_name', 'flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_workflow_result',
+        description: 'Get the result of a workflow run, optionally by job ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Optional workflow job ID' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'run_workflow',
+        description: 'Run a Langflow 1.12.x v2 workflow with sync, stream, or background mode.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' },
+                input_value: { type: 'string', description: 'Chat-style input value' },
+                mode: { type: 'string', enum: ['sync', 'stream', 'background'], description: 'Execution mode' },
+                stream_protocol: { type: 'string', description: 'Streaming protocol, for example langflow or agui' },
+                expose_graph_state: {
+                    type: ['boolean', 'null'],
+                    description: 'For streaming runs, include per-node graph events. Omitted or null uses the protocol default: false for AG-UI and true for Langflow. Ignored in sync mode.'
+                },
+                data: { type: ['object', 'null'], description: 'Optional live-canvas flow data override' },
+                files: { type: ['array', 'null'], items: { type: 'string' }, description: 'Pre-uploaded file paths' },
+                globals: { type: 'object', description: 'Request-level global variables' },
+                idempotency_key: { type: ['string', 'null'], description: 'Deduplication key for background submits' },
+                output_ids: { type: ['array', 'null'], items: { type: 'string' }, description: 'Output component IDs for sync mode' },
+                session_id: { type: ['string', 'null'], description: 'Optional session ID' },
+                start_component_id: { type: ['string', 'null'], description: 'Optional partial-run start component' },
+                stop_component_id: { type: ['string', 'null'], description: 'Optional partial-run stop component' },
+                tweaks: { type: 'object', description: 'Per-component parameter overrides' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'stop_workflow',
+        description: 'Stop a running workflow job by job ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Workflow job ID to stop' }
+            },
+            required: ['job_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'list_mcp_servers',
+        description: 'List configured MCP servers. Optionally include action counts.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action_count: { type: 'boolean', description: 'Include action counts per server' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_mcp_server',
+        description: 'Get the configuration of a specific MCP server by name.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                server_name: { type: 'string', description: 'MCP server name' }
+            },
+            required: ['server_name']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_mcp_server',
+        description: 'Create an MCP server configuration (stdio command or remote URL based).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                server_name: { type: 'string', description: 'MCP server name' },
+                config: {
+                    type: 'object',
+                    description: 'MCP server config',
+                    properties: {
+                        command: { type: 'string', description: 'Command for stdio servers' },
+                        args: { type: 'array', items: { type: 'string' }, description: 'Command arguments' },
+                        env: { type: 'object', description: 'Environment variables' },
+                        url: { type: 'string', description: 'URL for remote servers' },
+                        headers: { type: 'object', description: 'HTTP headers for remote servers' }
+                    }
+                }
+            },
+            required: ['server_name', 'config']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_mcp_server',
+        description: 'Update an existing MCP server configuration by name.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                server_name: { type: 'string', description: 'MCP server name' },
+                config: {
+                    type: 'object',
+                    description: 'MCP server config',
+                    properties: {
+                        command: { type: 'string', description: 'Command for stdio servers' },
+                        args: { type: 'array', items: { type: 'string' }, description: 'Command arguments' },
+                        env: { type: 'object', description: 'Environment variables' },
+                        url: { type: 'string', description: 'URL for remote servers' },
+                        headers: { type: 'object', description: 'HTTP headers for remote servers' }
+                    }
+                }
+            },
+            required: ['server_name', 'config']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_mcp_server',
+        description: 'Delete an MCP server configuration by name.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                server_name: { type: 'string', description: 'MCP server name to delete' }
+            },
+            required: ['server_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_mcp_project_config',
+        description: 'Get the MCP configuration for a project. Optionally filter to only MCP-enabled flows.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' },
+                mcp_enabled: { type: 'boolean', description: 'Only return MCP-enabled flows' }
+            },
+            required: ['project_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'update_mcp_project_config',
+        description: 'Update the MCP configuration (settings and auth settings) for a project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' },
+                settings: { type: 'array', items: { type: 'object' }, description: 'Per-flow MCP settings' },
+                auth_settings: { type: 'object', description: 'Optional auth settings' }
+            },
+            required: ['project_id', 'settings']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_mcp_project_installed',
+        description: 'Get the installation status of a project as an MCP server across clients.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' }
+            },
+            required: ['project_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'install_mcp_project',
+        description: 'Install a project as an MCP server into a target client, optionally specifying transport.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' },
+                client: { type: 'string', description: 'Target client (e.g. cursor, claude)' },
+                transport: { type: 'string', description: 'Optional transport' }
+            },
+            required: ['project_id', 'client']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_mcp_project_composer_url',
+        description: 'Get the MCP Composer URL for a project.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project ID (UUID)' }
+            },
+            required: ['project_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_authz_roles',
+        description: 'List authorization roles. Optionally filter by system flag or name with pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                is_system: { type: 'boolean', description: 'Filter by system roles' },
+                name: { type: 'string', description: 'Filter by role name' },
+                limit: { type: 'number', description: 'Maximum number of results' },
+                offset: { type: 'number', description: 'Result offset for pagination' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_authz_role',
+        description: 'Get a single authorization role by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role_id: { type: 'string', description: 'Role ID' }
+            },
+            required: ['role_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_authz_role',
+        description: 'Create an authorization role with optional permissions and a parent role.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Role name' },
+                description: { type: 'string', description: 'Role description' },
+                permissions: { type: 'array', items: { type: 'string' }, description: 'Permission identifiers' },
+                parent_role_id: { type: 'string', description: 'Parent role ID for inheritance' }
+            },
+            required: ['name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_authz_role',
+        description: 'Update an existing authorization role by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role_id: { type: 'string', description: 'Role ID' },
+                name: { type: 'string', description: 'Role name' },
+                description: { type: 'string', description: 'Role description' },
+                permissions: { type: 'array', items: { type: 'string' }, description: 'Permission identifiers' },
+                parent_role_id: { type: 'string', description: 'Parent role ID for inheritance' }
+            },
+            required: ['role_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_authz_role',
+        description: 'Delete an authorization role by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role_id: { type: 'string', description: 'Role ID to delete' }
+            },
+            required: ['role_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_authz_role_assignments',
+        description: 'List role assignments, optionally filtered by user, role, or domain.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user_id: { type: 'string', description: 'Filter by user ID' },
+                role_id: { type: 'string', description: 'Filter by role ID' },
+                domain_type: { type: 'string', description: 'Filter by domain type' },
+                domain_id: { type: 'string', description: 'Filter by domain ID' },
+                limit: { type: 'number', description: 'Maximum number of results' },
+                offset: { type: 'number', description: 'Result offset for pagination' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_authz_role_assignment',
+        description: 'Assign a role to a user, optionally scoped to a domain.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user_id: { type: 'string', description: 'User ID' },
+                role_id: { type: 'string', description: 'Role ID' },
+                domain_type: { type: 'string', description: 'Domain type: global, org, workspace, or project' },
+                domain_id: { type: 'string', description: 'Domain ID for the scope' }
+            },
+            required: ['user_id', 'role_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'delete_authz_role_assignment',
+        description: 'Delete a role assignment from a user by its assignment ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                assignment_id: { type: 'string', description: 'Role assignment ID to delete' }
+            },
+            required: ['assignment_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_authz_teams',
+        description: 'List authorization teams, optionally filtered by search term or active flag.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                search: { type: 'string', description: 'Search term for team names' },
+                is_active: { type: 'boolean', description: 'Filter by active teams' },
+                limit: { type: 'number', description: 'Maximum number of results' },
+                offset: { type: 'number', description: 'Result offset for pagination' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_authz_team',
+        description: 'Get a single authorization team by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID' }
+            },
+            required: ['team_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_authz_team',
+        description: 'Create an authorization team within an administrative domain.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_name: { type: 'string', description: 'Team name' },
+                adom_name: { type: 'string', description: 'Administrative domain name' },
+                description: { type: 'string', description: 'Team description' },
+                is_active: { type: 'boolean', description: 'Whether the team is active' }
+            },
+            required: ['team_name', 'adom_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_authz_team',
+        description: 'Update an existing authorization team by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID' },
+                team_name: { type: 'string', description: 'Team name' },
+                adom_name: { type: 'string', description: 'Administrative domain name' },
+                description: { type: 'string', description: 'Team description' },
+                is_active: { type: 'boolean', description: 'Whether the team is active' }
+            },
+            required: ['team_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_authz_team',
+        description: 'Delete an authorization team by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID to delete' }
+            },
+            required: ['team_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_authz_team_members',
+        description: 'List members of an authorization team with pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID' },
+                limit: { type: 'number', description: 'Maximum number of results' },
+                offset: { type: 'number', description: 'Result offset for pagination' }
+            },
+            required: ['team_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'add_authz_team_member',
+        description: 'Add a user to an authorization team.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID' },
+                user_id: { type: 'string', description: 'User ID to add' },
+                source: { type: 'string', description: 'Membership source: manual or sso' }
+            },
+            required: ['team_id', 'user_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'remove_authz_team_member',
+        description: 'Remove a user from an authorization team.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                team_id: { type: 'string', description: 'Team ID' },
+                user_id: { type: 'string', description: 'User ID to remove' }
+            },
+            required: ['team_id', 'user_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_authz_shares',
+        description: 'List resource shares, optionally filtered by resource, target, or scope.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource_type: { type: 'string', description: 'Filter by resource type' },
+                resource_id: { type: 'string', description: 'Filter by resource ID' },
+                target_id: { type: 'string', description: 'Filter by target ID' },
+                scope: { type: 'string', description: 'Filter by share scope' },
+                limit: { type: 'number', description: 'Maximum number of results' },
+                offset: { type: 'number', description: 'Result offset for pagination' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_authz_share',
+        description: 'Get a single resource share by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                share_id: { type: 'string', description: 'Share ID' }
+            },
+            required: ['share_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_authz_share',
+        description: 'Share a resource with a scope and optional target and permission level.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource_type: { type: 'string', description: 'Resource type: flow, deployment, project, knowledge_base, variable, or file' },
+                resource_id: { type: 'string', description: 'Resource ID to share' },
+                scope: { type: 'string', description: 'Share scope: private, team, user, or public' },
+                target_id: { type: 'string', description: 'Target ID for the share' },
+                permission_level: { type: 'string', description: 'Permission level: read, write, execute, or admin' }
+            },
+            required: ['resource_type', 'resource_id', 'scope']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'update_authz_share',
+        description: 'Update the permission level of a resource share.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                share_id: { type: 'string', description: 'Share ID' },
+                permission_level: { type: 'string', description: 'Permission level: read, write, execute, or admin' }
+            },
+            required: ['share_id', 'permission_level']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_authz_share',
+        description: 'Delete a resource share by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                share_id: { type: 'string', description: 'Share ID to delete' }
+            },
+            required: ['share_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_authz_audit',
+        description: 'Query the authorization audit log with filters and pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user_id: { type: 'string', description: 'Filter by user ID' },
+                actor_type: { type: 'string', enum: ['user', 'api_key', 'unknown', 'anonymous_public'], description: 'Filter by credential actor type; unknown also includes legacy rows without a type' },
+                actor_id: { type: 'string', description: 'Filter by credential actor UUID' },
+                resource_type: { type: 'string', description: 'Filter by resource type' },
+                resource_id: { type: 'string', description: 'Filter by resource ID' },
+                action: { type: 'string', description: 'Filter by audit action' },
+                exclude_action: { type: 'array', items: { type: 'string' }, description: 'Exclude rows matching any of these action names' },
+                result: { type: 'string', enum: ['allow', 'deny', 'owner_override', 'skip'], description: 'Filter by result outcome' },
+                event: { type: 'array', items: { type: 'string' }, description: 'Include rows matching any of these details.event classes' },
+                exclude_event: { type: 'array', items: { type: 'string' }, description: 'Exclude these details.event classes; legacy unclassified rows remain included' },
+                since: { type: 'string', description: 'Start timestamp (ISO 8601)' },
+                until: { type: 'string', description: 'End timestamp (ISO 8601)' },
+                page: { type: 'number', description: 'Page number' },
+                size: { type: 'number', description: 'Page size' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_my_permissions',
+        description: 'Get the calling user effective permissions for a set of resources.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource_type: { type: 'string', description: 'Resource type: flow, deployment, project, knowledge_base, variable, file, or component' },
+                resource_ids: { type: 'array', items: { type: 'string' }, description: 'Resource IDs to check' },
+                actions: { type: 'array', items: { type: 'string' }, description: 'Specific actions to evaluate' },
+                domain: { type: 'string', description: 'Domain scope for the check' }
+            },
+            required: ['resource_type', 'resource_ids']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'create_memory_base',
+        description: 'Create a memory base for a flow (experimental, hidden in Langflow OpenAPI).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Memory base name' },
+                flow_id: { type: 'string', description: 'Associated flow ID' },
+                threshold: { type: 'number', description: 'Capture threshold' },
+                auto_capture: { type: 'boolean', description: 'Automatically capture memories' },
+                embedding_provider: { type: 'string', description: 'Embedding provider selected for the embedding model' },
+                embedding_model: { type: 'string', description: 'Embedding model name' },
+                preprocessing: { type: 'boolean', description: 'Enable preprocessing' },
+                preproc_model: { type: 'string', description: 'Preprocessing model name' },
+                preproc_instructions: { type: 'string', description: 'Preprocessing instructions' },
+                preproc_kill_phrase: { type: 'string', description: 'Preprocessing kill phrase' }
+            },
+            required: ['name', 'flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'list_memory_bases',
+        description: 'List memory bases, optionally filtered by flow with pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Filter by flow ID' },
+                page: { type: 'number', description: 'Page number' },
+                size: { type: 'number', description: 'Page size' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_memory_base',
+        description: 'Get a single memory base by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_memory_base_sessions',
+        description: 'List sessions stored in a memory base with pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' },
+                page: { type: 'number', description: 'Page number' },
+                size: { type: 'number', description: 'Page size' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_memory_base_messages',
+        description: 'List messages stored in a memory base, optionally filtered by session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' },
+                session_id: { type: 'string', description: 'Filter by session ID' },
+                page: { type: 'number', description: 'Page number' },
+                size: { type: 'number', description: 'Page size' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'update_memory_base',
+        description: 'Update an existing memory base by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' },
+                name: { type: 'string', description: 'Memory base name' },
+                threshold: { type: 'number', description: 'Capture threshold' },
+                auto_capture: { type: 'boolean', description: 'Automatically capture memories' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'delete_memory_base',
+        description: 'Delete a memory base and its stored memories by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID to delete' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'flush_memory_base',
+        description: 'Flush a memory base session, persisting captured memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' },
+                session_id: { type: 'string', description: 'Session ID to flush' }
+            },
+            required: ['memory_base_id', 'session_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'check_memory_base_mismatch',
+        description: 'Check a memory base for configuration or embedding mismatches.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'regenerate_memory_base',
+        description: 'Regenerate a memory base, rebuilding its stored memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memory_base_id: { type: 'string', description: 'Memory base ID' }
+            },
+            required: ['memory_base_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'test_knowledge_base_connection',
+        description: 'Test a connection to a knowledge base backend.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                backend_type: { type: 'string', description: 'Backend type to test' },
+                backend_config: { type: 'object', description: 'Backend connection configuration' }
+            },
+            required: ['backend_type']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_knowledge_base_connectors',
+        description: 'List available knowledge base ingestion connectors.',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'ingest_knowledge_base_folder',
+        description: 'Ingest a local folder into a knowledge base with chunking options.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                path: { type: 'string', description: 'Folder path to ingest' },
+                recursive: { type: 'boolean', description: 'Recurse into subfolders' },
+                extensions: { type: 'array', items: { type: 'string' }, description: 'File extensions to include' },
+                max_file_size_bytes: { type: 'number', description: 'Maximum file size in bytes' },
+                source_name: { type: 'string', description: 'Source name label' },
+                chunk_size: { type: 'number', description: 'Chunk size' },
+                chunk_overlap: { type: 'number', description: 'Chunk overlap' },
+                separator: { type: 'string', description: 'Chunk separator' },
+                metadata: { type: 'object', description: 'Metadata applied to all files' },
+                per_file_metadata: { type: 'object', description: 'Per-file metadata overrides' }
+            },
+            required: ['kb_name', 'path']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'ingest_knowledge_base_connector',
+        description: 'Ingest content into a knowledge base from a configured connector source.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                source_type: { type: 'string', description: 'Connector source type' },
+                source_config: { type: 'object', description: 'Connector source configuration' },
+                source_name: { type: 'string', description: 'Source name label' },
+                chunk_size: { type: 'number', description: 'Chunk size' },
+                chunk_overlap: { type: 'number', description: 'Chunk overlap' },
+                separator: { type: 'string', description: 'Chunk separator' }
+            },
+            required: ['kb_name', 'source_type']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_knowledge_base_metadata_keys',
+        description: 'Get the available metadata keys for a knowledge base.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' }
+            },
+            required: ['kb_name']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_knowledge_base_runs',
+        description: 'List ingestion runs for a knowledge base with pagination.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                page: { type: 'number', description: 'Page number' },
+                limit: { type: 'number', description: 'Maximum number of results' }
+            },
+            required: ['kb_name']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_knowledge_base_run',
+        description: 'Get a single knowledge base ingestion run by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                kb_name: { type: 'string', description: 'Knowledge base name' },
+                run_id: { type: 'string', description: 'Ingestion run ID' }
+            },
+            required: ['kb_name', 'run_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'reload_extension_bundle',
+        description: 'Reload an extension bundle (requires LANGFLOW_ENABLE_EXTENSION_RELOAD on the server).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                extension_id: { type: 'string', description: 'Extension ID' },
+                bundle_name: { type: 'string', description: 'Bundle name to reload' }
+            },
+            required: ['extension_id', 'bundle_name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_extension_events',
+        description: 'Get extension events for the current user, optionally since a UTC epoch cursor.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                since: { type: 'number', description: 'UTC epoch timestamp; return events after this cursor' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_agentic_file',
+        description: 'Get an agentic workspace file, optionally as a downloadable payload.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'File path' },
+                download: { type: 'boolean', description: 'Return the file content for download' }
+            },
+            required: ['path']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'reset_agentic_session',
+        description: 'Reset an agentic session, optionally targeting a specific session ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID to reset' }
+            }
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_flow_note_translations',
+        description: 'Get localized note translations for a flow by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_job_queue_metrics',
+        description: 'Get job queue metrics (superuser-only).',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_a2a_agents',
+        description: 'List available A2A (Agent-to-Agent) agents (Langflow 1.11.x). Requires server-side A2A enablement (LANGFLOW_A2A_ENABLED).',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_a2a_agent_card',
+        description: 'Get the A2A agent card (.well-known/agent-card.json) for a flow (Langflow 1.11.x). Requires server-side A2A enablement.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'invoke_a2a_jsonrpc',
+        description: 'Invoke a flow via the A2A JSON-RPC endpoint (Langflow 1.11.x). The JSON-RPC envelope is a passthrough; validation lives server-side.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' },
+                jsonrpc: { type: 'string', description: 'JSON-RPC version (e.g. "2.0")' },
+                method: { type: 'string', description: 'JSON-RPC method name' },
+                params: { type: ['object', 'array'], description: 'JSON-RPC params (object or positional array)' },
+                id: { type: ['string', 'number'], description: 'JSON-RPC request ID' }
+            },
+            required: ['flow_id', 'method']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'list_pending_workflows',
+        description: 'List pending human-in-the-loop requests for a required flow ID (Langflow 1.11.x).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID to list pending HITL requests for' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_workflow_events',
+        description: 'Re-attach to a workflow job event stream by job ID (Langflow 1.11.x). Streaming is not incrementally surfaced; the initial payload is returned.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Workflow job ID' }
+            },
+            required: ['job_id']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'resume_workflow',
+        description: 'Resume a paused human-in-the-loop workflow with the pending request ID and optional decision (Langflow 1.11.x).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                job_id: { type: 'string', description: 'Workflow job ID' },
+                request_id: { type: 'string', description: 'Pending HITL request ID' },
+                decision: { type: ['object', 'null'], description: 'Optional HITL decision payload' }
+            },
+            required: ['job_id', 'request_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'run_public_workflow',
+        description: 'Run a public (unauthenticated-eligible) workflow (Langflow 1.11.x). Stream-only execution; streaming is not incrementally surfaced.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'Flow ID' },
+                input_value: { type: 'string', description: 'Chat-style input value (max 65536 characters)' },
+                mode: { type: 'string', enum: ['stream'], description: 'Always stream for public execution' },
+                stream_protocol: { type: 'string', description: 'Streaming protocol, for example langflow or agui' },
+                files: { type: ['array', 'null'], items: { type: 'string' }, description: 'Flow-scoped pre-uploaded file paths' },
+                session_id: { type: ['string', 'null'], description: 'Optional caller session (max 256 characters)' },
+                start_component_id: { type: ['string', 'null'], description: 'Optional partial-run start component' },
+                stop_component_id: { type: ['string', 'null'], description: 'Optional partial-run stop component' }
+            },
+            required: ['flow_id']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'get_healthz',
+        description: 'Get the Langflow Kubernetes-style readiness report from /healthz (Langflow 1.12.x).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_model_provider_descriptors',
+        description: 'List policy-visible model providers with stable IDs and display names (Langflow 1.12.x).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                purpose: { type: 'string', enum: ['use', 'configure'], description: 'Optional provider visibility purpose' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_model_provider_policy',
+        description: 'Read the install-wide approved model-provider policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'replace_model_provider_policy',
+        description: 'Replace the install-wide approved model-provider policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                approved_provider_ids: { type: 'array', items: { type: 'string' }, description: 'Complete approved provider ID set' }
+            },
+            required: ['approved_provider_ids']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_catalog_component_policy',
+        description: 'Read the global blocked-component catalog policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'replace_catalog_component_policy',
+        description: 'Replace the global blocked-component catalog policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: {
+            type: 'object',
+            properties: { blocked: { type: 'array', items: { type: 'string' }, description: 'Complete blocked component key set' } },
+            required: ['blocked']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_catalog_template_policy',
+        description: 'Read the global blocked-template catalog policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'replace_catalog_template_policy',
+        description: 'Replace the global blocked-template catalog policy (superuser-only Langflow 1.12.x API).',
+        inputSchema: {
+            type: 'object',
+            properties: { blocked: { type: 'array', items: { type: 'string' }, description: 'Complete blocked template key set' } },
+            required: ['blocked']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_catalog_policy_usage',
+        description: 'Count flows using each catalog component (superuser-only Langflow 1.12.x API).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_catalog_policy_usage_flows',
+        description: 'List flows affected by blocking a catalog component key (superuser-only Langflow 1.12.x API).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                component: { type: 'string', description: 'Component key to look up' },
+                limit: { type: 'number', description: 'Maximum number of flows, 1-500' }
+            },
+            required: ['component']
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'get_policy_bundle',
+        description: 'Read the atomic provider-and-catalog policy bundle (superuser-only Langflow 1.12.x API).',
+        inputSchema: { type: 'object', properties: {} },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'replace_policy_bundle',
+        description: 'Atomically replace the provider-and-catalog policy bundle using an expected revision (Langflow 1.12.x).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                expected_revision: { type: 'number', description: 'Revision read before the replacement' },
+                approved_provider_ids: { type: 'array', items: { type: 'string' } },
+                blocked_component_keys: { type: 'array', items: { type: 'string' } },
+                blocked_template_keys: { type: 'array', items: { type: 'string' } },
+                blocked_model_keys: { type: 'array', items: { type: 'string' } },
+                reason: { type: ['string', 'null'], description: 'Optional change reason, max 1024 characters' }
+            },
+            required: ['expected_revision', 'approved_provider_ids', 'blocked_component_keys', 'blocked_template_keys']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'list_policy_bundle_history',
+        description: 'List historical policy bundle revisions (superuser-only Langflow 1.12.x API).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Number of revisions, 1-200' },
+                before_revision: { type: ['number', 'null'], description: 'Return revisions before this number' }
+            }
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'rollback_policy_bundle',
+        description: 'Roll back the policy bundle to a prior revision with optimistic concurrency protection (Langflow 1.12.x).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                revision: { type: 'number', description: 'Target revision' },
+                expected_revision: { type: 'number', description: 'Current revision required for the rollback' },
+                reason: { type: ['string', 'null'], description: 'Optional rollback reason, max 1024 characters' }
+            },
+            required: ['revision', 'expected_revision']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    {
+        name: 'upsert_project',
+        description: 'Create or update a project at a caller-supplied ID using Langflow 1.12.x PUT upsert semantics.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'string', description: 'Project UUID' },
+                name: { type: 'string', description: 'Project name' },
+                description: { type: ['string', 'null'], description: 'Project description' },
+                auth_settings: { type: ['object', 'null'], description: 'Project authentication settings' },
+                components_list: { type: ['array', 'null'], items: { type: 'string' } },
+                flows_list: { type: ['array', 'null'], items: { type: 'string' } }
+            },
+            required: ['project_id', 'name']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    {
+        name: 'agentic_assist_run',
+        description: 'Run the Langflow agentic assistant headlessly and persist its flow changes (Langflow 1.12.x SSE API).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instruction: { type: 'string', description: 'Assistant instruction' },
+                flow_id: { type: ['string', 'null'], description: 'Optional existing flow ID' },
+                provider: { type: ['string', 'null'], description: 'Optional model provider' },
+                model_name: { type: ['string', 'null'], description: 'Optional model name' },
+                session_id: { type: ['string', 'null'], description: 'Optional assistant session ID' }
+            },
+            required: ['instruction']
+        },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
     }
 ];
 //# sourceMappingURL=tools.js.map