@elastic.io/mcp 1.0.0-beta

package/dist/tools/definitions.js

@@ -0,0 +1,915 @@
+import { withConfirmationSchemas, DESTRUCTIVE_TOOL_NAMES } from './confirmation.js';
+const TOOL_DEFS = [
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.CREATE_AUTH_CLIENT,
+        description: 'Register a new Authentication Client (oauth2, basic, api_key, noauth) for a component. For basic, api_key, and noauth types, credentials is typically an empty object {} and is created with global scope by default (no contract/tenant/workspace relationship).\n\nPreconditions: You MUST have called get_component for this componentId first to inspect the descriptor and determine the correct auth type. Do NOT guess the auth type.\nPostconditions: Returns the created auth client with its ID. Use this ID when creating secrets via create_secret.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                componentId: {
+                    type: 'string',
+                    description: 'The unique ID of the component.'
+                },
+                name: {
+                    type: 'string',
+                    description: 'The name of the authentication client.'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['oauth2', 'basic', 'api_key', 'noauth'],
+                    description: 'The type of authentication client.'
+                },
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional. Workspace ID scope for the client. If contractId, tenantId, and workspaceId are all omitted, the client visibility will be global.'
+                },
+                contractId: {
+                    type: 'string',
+                    description: 'Optional. Contract ID scope for the client.'
+                },
+                tenantId: {
+                    type: 'string',
+                    description: 'Optional. Tenant ID scope for the client.'
+                },
+                credentials: {
+                    type: 'object',
+                    description: 'Optional client credentials block. Defaults to {} for basic, api_key, and noauth. For oauth2, must contain client_id, client_secret, refresh_token_uri, token_uri, and auth_uri.'
+                }
+            },
+            required: ['componentId', 'name', 'type']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.CREATE_CREDENTIALS,
+        description: 'Create credentials or a secret connection (along with its authentication client) for a component in a workspace based on its authorization type. If it uses secrets (basic, api_key, noauth), the client is created with global visibility and credentials: {} by default, while oauth2 client is created workspace-scoped.\n\nPreconditions: You MUST have called get_component for this componentId to inspect the descriptor and determine the correct auth type (secrets vs plain credentials). You MUST have called list_credentials and list_secrets to verify no existing credentials can be reused.\nPostconditions: Returns the created credential/secret ID. Use this ID in the flow node\'s credentials_id or secret_id field.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The workspace ID.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The component ID.'
+                },
+                name: {
+                    type: 'string',
+                    description: 'Optional name for the credential, secret, or auth client to be created.'
+                },
+                authClientId: {
+                    type: 'string',
+                    description: 'Optional existing auth client ID to reuse if the component uses secrets.'
+                },
+                clientConfig: {
+                    type: 'object',
+                    description: 'Optional client configuration for creating a new auth client. Fields: {name, type, credentials, scope, workspaceId, contractId, tenantId}. Defaults to global scope and empty credentials for basic/api_key/noauth. Example for oauth2: {"type": "oauth2", "credentials": {"client_id": "...", "client_secret": "...", "auth_uri": "...", "token_uri": "..."}}'
+                },
+                secretConfig: {
+                    type: 'object',
+                    description: 'Optional secret configuration for creating a secret. Fields: {name, type, credentials}. Example credentials properties per type:\n- oauth2: {"access_token": "...", "refresh_token": "..."}\n- basic: {"username": "...", "password": "..."}\n- api_key: {"headerName": "...", "headerValue": "..."}\n- noauth: {}'
+                },
+                credentialConfig: {
+                    type: 'object',
+                    description: 'Optional credential configuration for creating plain credentials. Fields: {name, keys}. "keys" contains the flat key-value pairs defined in the component descriptor fields schema. Example: {"keys": {"apiKey": "my-key"}}'
+                }
+            },
+            required: ['workspaceId', 'componentId']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.CREATE_FLOW,
+        description: 'Create a new integration flow. The body of the request must be fully constructed as a valid JSON API payload containing type: "flow", attributes (name, type, graph), and relationships (workspace). CRITICAL: All edges with mappers MUST follow the JSONata mapping rules (use $getPassthrough().step_id.body.field for variables, and use double quotes (escaped as \\") for literals without wrapping the entire expression in outer quotes).\n\nPreconditions:\n1. You MUST have read the resource elasticio://docs/flow-building-guide in this session.\n2. You MUST have called get_component for EVERY component used in the flow.\n3. You MUST have called list_credentials/list_secrets for EVERY component that requires auth.\n4. You MUST have called init_dynamic_metadata for EVERY step with dynamicMetadata:true to retrieve BOTH input AND output schemas. Mapper keys come from the TARGET step\'s input schema; mapper values MUST use real field names from the SOURCE step\'s output schema — NEVER guess field names.\n5. You MUST have presented a summary of all steps to the user and received confirmation.\nPostconditions: Returns the created flow with its ID. The flow is created in INACTIVE state. Call start_flow to activate it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                body: {
+                    type: 'object',
+                    description: 'The JSON API compliant request body payload.'
+                }
+            },
+            required: ['body']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.CREATE_SECRET,
+        description: 'Create a new Authentication Secret (auth-secret) inside a specific workspace linked to an auth client.\n\nPreconditions: You MUST have a valid authClientId from a previous create_auth_client call or from list_auth_clients. You MUST have called get_component to determine the correct secret type and required credential fields.\nPostconditions: Returns the created secret with its ID. Use this secret_id in flow nodes that require authentication.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique workspace ID.'
+                },
+                name: {
+                    type: 'string',
+                    description: 'The name of the authentication secret.'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['oauth2', 'basic', 'api_key', 'noauth'],
+                    description: 'The sub-type of authentication secret.'
+                },
+                authClientId: {
+                    type: 'string',
+                    description: 'The unique ID of the auth client this secret uses.'
+                },
+                credentials: {
+                    type: 'object',
+                    description: 'The secret credentials block (an empty "fields": {} object and "state": "ready" are automatically injected). Example configurations per type:\n- oauth2: {"access_token": "...", "expires_in": 3599, "refresh_token": "...", "scope": "...", "additional_params": "..."}\n- basic: {"username": "...", "password": "..."}\n- api_key: {"headerName": "...", "headerValue": "..."}\n- noauth: {}'
+                }
+            },
+            required: ['workspaceId', 'name', 'type', 'authClientId', 'credentials']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.EXECUTE_RAW_API_REQUEST,
+        description: 'Execute a raw HTTP request against the elastic.io REST API. Intended as a fallback or escape hatch: (1) for edge-case endpoints not covered by dedicated tools, or (2) when dedicated tools fail, error out, or are blocked by platform/validation limitations.\n\nPreconditions: Always prefer dedicated tools (e.g. list_flows, get_flow, update_flow_draft, list_workspaces, etc.) first for standard operations. Only fall back to this tool if no dedicated tool exists or if the dedicated tool fails/cannot complete the operation. Verify the endpoint path and payload format against the API documentation at https://api.elastic.io/docs/v2 first.\nPostconditions: Returns the raw API response. GET requests do not require confirmation; mutating methods (POST, PUT, PATCH, DELETE) require confirmed: true.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                method: {
+                    type: 'string',
+                    enum: ['GET', 'POST', 'PATCH', 'PUT', 'DELETE'],
+                    description: 'The HTTP request method.'
+                },
+                path: {
+                    type: 'string',
+                    description: 'The API endpoint path (e.g. /workspaces or /flows/123/steps).'
+                },
+                body: {
+                    type: 'object',
+                    description: 'The optional request body payload.'
+                }
+            },
+            required: ['method', 'path']
+        }
+    },
+    {
+        name: 'get_auth_client',
+        description: 'Retrieve details for a specific authentication client by its ID. To specify the scope of the request, you must provide one of workspaceId, contractId, or tenantId as a parameter (unless retrieving a global client).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                authClientId: {
+                    type: 'string',
+                    description: 'The unique identifier of the auth client.'
+                },
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional. Scopes the request to the given workspace. Only one of workspaceId, contractId, or tenantId should be specified.'
+                },
+                contractId: {
+                    type: 'string',
+                    description: 'Optional. Scopes the request to the given contract.'
+                },
+                tenantId: {
+                    type: 'string',
+                    description: 'Optional. Scopes the request to the given tenant.'
+                }
+            },
+            required: ['authClientId']
+        }
+    },
+    {
+        name: 'get_component',
+        description: 'Retrieve the official technical definition of a specific component by its ID, including its available actions, triggers, settings, fields, and JSON input/output schema structures. This is the primary tool to discover component schemas and actions when building a new flow or step. Note that the schemas retrieved here describe what fields are configured and mapped on the UI, not the REST API payload graph representation directly.\n\nPreconditions: You MUST have obtained the componentId from list_components first. Do NOT guess or hardcode component IDs.\nPostconditions: After calling this tool, you MUST present the available actions/triggers to the user and ask which one to use. Do NOT choose an action/trigger without user confirmation. The response also provides commandPrefix and latestVersionId needed for building the flow node\'s command string.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component (e.g. aaa1111111bbb2222222ccc08).'
+                },
+                actionOrTriggerId: {
+                    type: 'string',
+                    description: 'Optional action or trigger ID to filter and return only that specific action or trigger schema, preventing token bloat.'
+                }
+            },
+            required: ['componentId']
+        }
+    },
+    {
+        name: 'get_credential',
+        description: 'Retrieve detailed configuration and metadata for a specific credential connection by its ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                credentialId: {
+                    type: 'string',
+                    description: 'The unique identifier of the credential connection.'
+                }
+            },
+            required: ['credentialId']
+        }
+    },
+    {
+        name: 'get_flow',
+        description: 'Get the detailed configuration, steps, and structure of a specific integration flow.\n\nPreconditions: You MUST have obtained the flowId from list_flows or from the user.\nPostconditions: The flow is marked as "inspected" in the session. This is a prerequisite for update_flow and update_flow_draft (Playbook B).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the integration flow.'
+                },
+                include: {
+                    type: 'string',
+                    enum: ['flow-containers', 'descriptor'],
+                    description: 'Optional related resources to include: "flow-containers" or "descriptor".'
+                }
+            },
+            required: ['flowId']
+        }
+    },
+    {
+        name: 'get_flow_draft',
+        description: 'Retrieve the current unpublished draft version of an integration flow.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the flow.'
+                }
+            },
+            required: ['flowId']
+        }
+    },
+    {
+        name: 'get_logs',
+        description: 'Retrieve execution logs for integration flows, filtered and formatted token-safely. Returns a `summary` object with `time_range`, `overall_levels` (count by level), and `per_step` (per step_id: component_name, method, total, by_level counts, first_error). Use the summary to present a structured Execution Analysis, then follow Playbook C to ask the user whether they want fixes applied or a full assessment with improvement suggestions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                flowIds: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Optional array of flow IDs to filter logs.'
+                },
+                from: {
+                    type: 'string',
+                    description: 'Optional start date of the period (ISO 8601 format).'
+                },
+                to: {
+                    type: 'string',
+                    description: 'Optional end date of the period (ISO 8601 format).'
+                },
+                search: {
+                    type: 'string',
+                    description: 'Optional search term to filter log messages.'
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Optional number of items to skip from the beginning. Default is 0.'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional number of items to return. Default is 50.',
+                    default: 50
+                },
+                levels: {
+                    type: 'array',
+                    items: {
+                        type: 'number',
+                        enum: [1, 10, 20, 30, 40, 50, 60]
+                    },
+                    description: 'Optional log levels (1-None, 10-trace, 20-debug, 30-info, 40-warn, 50-error, 60-fatal).'
+                },
+                containerId: {
+                    type: 'string',
+                    description: 'Optional container identifier.'
+                }
+            },
+            required: ['workspaceId']
+        }
+    },
+    {
+        name: 'get_scheduled_execution_result',
+        description: 'Retrieve the result of a dynamic select model, metadata, or credential verification execution. Optionally polls internally if the execution is still pending.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                executionId: {
+                    type: 'string',
+                    description: 'The unique identifier of the execution task.'
+                },
+                poll: {
+                    type: 'boolean',
+                    description: 'Optional. If true, the server polls internally for up to 15 seconds before returning. Defaults to true.',
+                    default: true
+                }
+            },
+            required: ['executionId']
+        }
+    },
+    {
+        name: 'get_secret',
+        description: 'Retrieve detailed configuration and metadata for a specific authentication secret by its ID and workspace ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                secretId: {
+                    type: 'string',
+                    description: 'The unique identifier of the secret.'
+                }
+            },
+            required: ['workspaceId', 'secretId']
+        }
+    },
+    {
+        name: 'init_dynamic_metadata',
+        description: 'Initiate a dynamic metadata schema retrieval for a component action or trigger when the action/trigger definition in the component descriptor has "dynamicMetadata": true. Do NOT use this tool if dynamicMetadata is not true. Returns an executionId that must be polled using get_scheduled_execution_result.\n\nThe result contains BOTH input ("in") and output ("out") schemas:\n- "in" schema: defines what fields the step EXPECTS as input (used as mapper KEYS on the incoming edge)\n- "out" schema: defines what fields the step EMITS as output (used as mapper VALUES on outgoing edges via $getPassthrough().step_id.body.<field>)\n\nIMPORTANT: You MUST call this tool for BOTH the source step (to get its output schema) AND the target step (to get its input schema) when building edge mappers. Do NOT guess or hallucinate output field names — always retrieve the real output schema.\n\nPreconditions: You MUST have called get_component and verified that the action/trigger has "dynamicMetadata": true. You MUST have a valid credentialId or secretId. You MUST have resolved all preceding dependent fields (e.g., selected the object type via init_dynamic_select_model first).\nPostconditions: Returns an executionId. You MUST call get_scheduled_execution_result with this executionId to get the actual schema. If status is "pending", wait 2-3 seconds and poll again.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component.'
+                },
+                versionId: {
+                    type: 'string',
+                    description: 'Optional. The component version ID (Git revision). Defaults to "latest".',
+                    default: 'latest'
+                },
+                actionOrTriggerName: {
+                    type: 'string',
+                    description: 'The name (ID string) of the action or trigger (mapped to the "module" field in the API payload).'
+                },
+                credentialId: {
+                    type: 'string',
+                    description: 'Optional. The credential ID to authorize the call. Either credentialId or secretId must be provided.'
+                },
+                secretId: {
+                    type: 'string',
+                    description: 'Optional. The secret ID to authorize the call. Either credentialId or secretId must be provided.'
+                },
+                fields: {
+                    type: 'object',
+                    description: 'Optional. Preceding field configurations/values that the dynamic metadata retrieval depends on.'
+                }
+            },
+            required: ['workspaceId', 'componentId', 'actionOrTriggerName']
+        }
+    },
+    {
+        name: 'init_dynamic_select_model',
+        description: 'Initiate a dynamic select model (dropdown list) retrieval for a component field when the field\'s model property in the component descriptor is a string (representing a dynamic model function). Do NOT use this tool for static fields where the model is a JSON object (whose options should be taken directly from the descriptor). Returns an executionId that must be polled using get_scheduled_execution_result.\n\nPreconditions: You MUST have called get_component and verified that the field\'s model property is a string (dynamic), not a JSON object (static). You MUST have a valid credentialId or secretId.\nPostconditions: Returns an executionId. You MUST call get_scheduled_execution_result with this executionId. Then you MUST present the dropdown options to the user and let them choose — do NOT select an option automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component.'
+                },
+                versionId: {
+                    type: 'string',
+                    description: 'Optional. The component version ID (Git revision). Defaults to "latest".',
+                    default: 'latest'
+                },
+                actionOrTriggerName: {
+                    type: 'string',
+                    description: 'The name (ID string) of the action or trigger.'
+                },
+                methodName: {
+                    type: 'string',
+                    description: 'The method name (function to call, retrieved from the descriptor\'s model property).'
+                },
+                credentialId: {
+                    type: 'string',
+                    description: 'Optional. The credential ID to authorize the call. Either credentialId or secretId must be provided.'
+                },
+                secretId: {
+                    type: 'string',
+                    description: 'Optional. The secret ID to authorize the call. Either credentialId or secretId must be provided.'
+                },
+                fields: {
+                    type: 'object',
+                    description: 'Optional. Preceding field configurations/values that the dynamic field depends on.'
+                }
+            },
+            required: ['workspaceId', 'componentId', 'actionOrTriggerName', 'methodName']
+        }
+    },
+    {
+        name: 'init_verify_credentials',
+        description: 'Initiate a credential verification request for a component. The verification process is asynchronous; this tool returns an executionId that must be polled using get_scheduled_execution_result to retrieve the final verification result.\n\nPreconditions: You MUST have a valid credentialId or secretId. You MUST have the componentId and workspaceId.\nPostconditions: Returns an executionId. You MUST call get_scheduled_execution_result with this executionId to get the verification result. If status is "pending", wait 2-3 seconds and poll again.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component.'
+                },
+                versionId: {
+                    type: 'string',
+                    description: 'Optional. The component version ID (Git revision). Defaults to "latest".',
+                    default: 'latest'
+                },
+                credentialId: {
+                    type: 'string',
+                    description: 'The unique identifier of the existing credential to verify. Either credentialId or secretId must be provided.'
+                },
+                secretId: {
+                    type: 'string',
+                    description: 'The unique identifier of the existing secret to verify. Either credentialId or secretId must be provided.'
+                },
+                fields: {
+                    type: 'object',
+                    description: 'Optional overrides for the credential/secret configuration fields to verify.'
+                },
+                logLevel: {
+                    type: 'string',
+                    enum: ['trace', 'debug', 'info', 'warn', 'error', 'fatal'],
+                    description: 'Optional. The log level of the component verification step.',
+                    default: 'info'
+                }
+            },
+            required: ['workspaceId', 'componentId']
+        }
+    },
+    {
+        name: 'list_auth_clients',
+        description: 'List registered authentication clients (OAuth2 configurations storing client ID and secret) available in a workspace, contract, or tenant.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'Optional. Show auth clients available in the given workspace (including contract\'s, tenant\'s, and global auth-clients). Only one of workspaceId, contractId, or tenantId should be specified.'
+                },
+                contractId: {
+                    type: 'string',
+                    description: 'Optional. Show auth clients available in the given contract (including tenant\'s and global auth-clients).'
+                },
+                tenantId: {
+                    type: 'string',
+                    description: 'Optional. Show auth clients available in the given tenant and global scope.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'Optional. Filter the auth clients for a specific component ID.'
+                }
+            },
+            required: []
+        }
+    },
+    {
+        name: 'list_components',
+        description: 'List all available component connectors in a specific workspace to retrieve their IDs. Returns a lightweight technical summary of each component. Does NOT contain real-world step configurations, usage examples, or JSONata mappings.\n\nPreconditions: You MUST have a workspaceId from list_workspaces. Always use the search parameter to filter results.\nPostconditions: If multiple components match, you MUST stop and ask the user which one to use. Do NOT proceed to get_component or any other tool until the user selects a specific component. After selecting, call get_component with the chosen componentId.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                search: {
+                    type: 'string',
+                    description: 'Optional search query to filter components by name or description.'
+                }
+            },
+            required: ['workspaceId']
+        }
+    },
+    {
+        name: 'list_contracts',
+        description: 'List all contracts accessible with the current user credentials.\n\nPreconditions: Only call this tool when the user explicitly asks to list contracts or when you need a contractId for subsequent operations and the user has not provided one.\nPostconditions: If multiple contracts are returned, you MUST stop and ask the user which contract to use. Do NOT assume or select one automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                pageSize: {
+                    type: 'number',
+                    description: 'Optional page size (number of items per page). Default is 20. Maximum is 20.',
+                    maximum: 20
+                },
+                pageNumber: {
+                    type: 'number',
+                    description: 'Optional page number (1-based index). Default is 1.'
+                }
+            },
+            required: []
+        }
+    },
+    {
+        name: 'list_credentials',
+        description: 'List pre-created, authenticated connections (credentials) in a workspace for a specific component ID. IMPORTANT: Some newer components (especially those using OAuth2 like Salesforce v2, REST API v2, Google Sheets v2, Zoho) use Secrets instead of Credentials. When looking for existing connections, you should check both list_credentials and list_secrets for the given component.\n\nPreconditions: You MUST have a componentId from list_components/get_component. Always call BOTH list_credentials AND list_secrets for the same component to get a complete picture.\nPostconditions: If multiple credentials are found, you MUST stop and ask the user which one to use. If no credentials are found, inform the user and offer to create new ones via create_credentials.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component to filter credentials.'
+                }
+            },
+            required: ['workspaceId', 'componentId']
+        }
+    },
+    {
+        name: 'list_flows',
+        description: 'List active and inactive integration flows in a specific workspace. Returns a lightweight summary of each flow. Use get_flow with the flow ID to retrieve its detailed configuration.\n\nPreconditions: You MUST have a workspaceId from list_workspaces or from the user.\nPostconditions: Returns flow summaries (id, name, status, stepCount). To get full configuration, call get_flow with the specific flowId.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                pageSize: {
+                    type: 'number',
+                    description: 'Optional page size (number of items per page). Default is 50.'
+                },
+                pageNumber: {
+                    type: 'number',
+                    description: 'Optional page number (1-based index). Default is 1.'
+                },
+                search: {
+                    type: 'string',
+                    description: 'Optional search query to filter flows by name or description.'
+                },
+                status: {
+                    type: 'string',
+                    enum: ['active', 'inactive'],
+                    description: 'Optional filter to list only "active" or "inactive" flows.'
+                },
+                type: {
+                    type: 'string',
+                    enum: ['ordinary', 'long_running'],
+                    description: 'Optional filter to list flows by type: "ordinary" or "long_running".'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'Optional filter to list flows that use a specific component ID.'
+                },
+                hasDraft: {
+                    type: 'boolean',
+                    description: 'Optional filter to list only flows with or without a draft.'
+                },
+                userId: {
+                    type: 'string',
+                    description: 'Optional filter to list flows created by a specific user ID.'
+                },
+                include: {
+                    type: 'string',
+                    enum: ['flow-containers', 'descriptor'],
+                    description: 'Optional related resources to include: "flow-containers" or "descriptor".'
+                },
+                sort: {
+                    type: 'string',
+                    enum: ['created_at', 'updated_at', 'name', '-created_at', '-updated_at', '-name'],
+                    description: 'Optional sorting fields: prefix with "-" for descending order.'
+                }
+            },
+            required: ['workspaceId']
+        }
+    },
+    {
+        name: 'list_secrets',
+        description: 'List authentication secrets in a workspace for a specific component ID. Secrets are typically used by newer OAuth2 components (such as Salesforce v2, REST API v2, Google Sheets v2, Zoho) to store and auto-refresh credentials. IMPORTANT: When searching for credentials/secrets, you should check both list_credentials and list_secrets for the given component.\n\nPreconditions: You MUST have a componentId from list_components/get_component. Always call BOTH list_credentials AND list_secrets for the same component.\nPostconditions: If multiple secrets are found, you MUST stop and ask the user which one to use. If no secrets are found, inform the user and offer to create new ones via create_credentials.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component to filter secrets.'
+                }
+            },
+            required: ['workspaceId', 'componentId']
+        }
+    },
+    {
+        name: 'list_workspaces',
+        description: 'List all workspaces accessible with the current user credentials, filtered by contractId.\n\nPreconditions: You MUST have a contractId from list_contracts. Do NOT call this without a contractId.\nPostconditions: If multiple workspaces are returned, you MUST stop and ask the user which workspace to use. Do NOT assume or select one automatically.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                contractId: {
+                    type: 'string',
+                    description: 'Optional contract ID to filter workspaces. Highly recommended for multi-tenant users.'
+                },
+                pageSize: {
+                    type: 'number',
+                    description: 'Optional page size (number of items per page). Default is 50.'
+                },
+                pageNumber: {
+                    type: 'number',
+                    description: 'Optional page number (1-based index). Default is 1.'
+                }
+            },
+            required: ['contractId']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.RUN_FLOW_NOW,
+        description: 'Trigger a manual, one-off execution of an integration flow.\n\nPreconditions: The flow MUST be in ACTIVE state. If the flow is inactive, call start_flow first. You SHOULD have called get_flow to verify the flow is properly configured before triggering execution.\nPostconditions: The flow execution is triggered asynchronously. Use get_logs to check execution results. After retrieving logs, follow Playbook C: present a structured Execution Analysis (health by step, error patterns, data flow), then ask the user whether they want fixes applied or a full assessment with improvement suggestions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the flow.'
+                }
+            },
+            required: ['flowId']
+        }
+    },
+    {
+        name: 'search_documentation',
+        description: 'Search the documentation semantically using Gemini Embedding 2 and Qdrant. Returns relevant text chunks and images. Note: This tool does NOT contain REST API payload examples, schemas, or flow JSON structures. For REST API flow payload structures, schemas, and modification guides, you must read the resource "elasticio://docs/flow-building-guide".\n\nPreconditions: Use this tool ONLY for conceptual/how-to questions about the platform. Do NOT use it to find API payload formats or JSON structures (use the flow-building-guide resource instead).\nPostconditions: Returns relevant documentation chunks. If the answer is not found, tell the user rather than guessing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The semantic query or phrase to search (e.g., "how to set up rebounds", "cron trigger format").'
+                }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'search_flow_samples',
+        description: 'Search the vector database of integration flow samples to find complete, real-world examples of how entire flows are structured and built. Use this ONLY when asked to search or explain general flow layouts. Calling this tool is strictly PROHIBITED during new flow creation or when discovering component/credential IDs (instead, ask the user).\n\nPreconditions: PROHIBITED during flow creation (Playbook A) or component/credential discovery. Only use when the user explicitly asks for examples or when debugging.\nPostconditions: Returns example flow structures. These are reference examples only — do NOT copy component IDs, credential IDs, or version hashes from them.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The natural language query or use case (e.g. "salesforce query and upsert", "cron trigger timer").'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional maximum number of matches to return. Default is 5.'
+                }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: 'search_flow_steps',
+        description: 'Search the vector database of individual flow steps to find actual real-world usage examples, concrete configurations, and JSONata mappings for a particular component or action. Use this ONLY for historical configuration reference. Calling this tool is strictly PROHIBITED during new flow creation or when discovering component/credential IDs (instead, ask the user).\n\nPreconditions: PROHIBITED during flow creation (Playbook A) or component/credential discovery. Only use for historical reference or when the user asks for configuration examples.\nPostconditions: Returns example step configurations. Do NOT copy component IDs, credential IDs, or version hashes from these examples — always use fresh values from get_component.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'The natural language query or component/action name (e.g. "salesforce create account step", "JSONata filter date modification").'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Optional maximum number of matches to return. Default is 5.'
+                }
+            },
+            required: ['query']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.START_FLOW,
+        description: 'Activate and start a configured integration flow.\n\nPreconditions: The flow MUST be in INACTIVE state and fully configured with valid components, credentials, and mappings. You SHOULD have called get_flow to verify the configuration.\nPostconditions: The flow transitions to ACTIVE state. Poll get_flow to confirm the status change.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the flow.'
+                }
+            },
+            required: ['flowId']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.STOP_FLOW,
+        description: 'Deactivate and stop a running integration flow.\n\nPreconditions: The flow MUST be in ACTIVE state.\nPostconditions: The flow transitions to INACTIVE state. You MUST poll get_flow until status === "inactive" before making any modifications (Playbook B requires this).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the flow.'
+                }
+            },
+            required: ['flowId']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.UPDATE_FLOW,
+        description: 'Update/Patch a specific integration flow directly. The body of the request must be fully constructed as a valid JSON API patch payload containing data (id, type: "flow", attributes, etc.). CRITICAL: All edges with mappers MUST follow the JSONata mapping rules (use $getPassthrough().step_id.body.field for variables, and use double quotes (escaped as \\") for literals without wrapping the entire expression in outer quotes).\n\nPreconditions (Playbook B — all required):\n1. You MUST have called get_flow to inspect the current graph.\n2. The flow MUST be INACTIVE. If active, call stop_flow first and poll get_flow until status === "inactive".\n3. You MUST have read the resource elasticio://docs/flow-building-guide.\n4. You MUST have called get_component for any NEW components being added.\n5. You MUST have called list_credentials/list_secrets for any NEW components requiring auth.\n6. For any modified or new edges with mappers, you MUST have called init_dynamic_metadata for BOTH the source step (to get its output schema for mapper values) AND the target step (to get its input schema for mapper keys). Do NOT guess output field names.\nPostconditions: Returns the updated flow. Call start_flow to reactivate it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the integration flow to update.'
+                },
+                expectedRevision: {
+                    type: 'string',
+                    description: 'The revision string from get_flow_build_status or get_flow. Required for optimistic concurrency control.'
+                },
+                body: {
+                    type: 'object',
+                    description: 'The JSON API compliant PATCH request body payload.'
+                }
+            },
+            required: ['flowId', 'body', 'expectedRevision']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.UPDATE_FLOW_DRAFT,
+        description: 'Update the draft layout, parameters, or step mappings of an integration flow directly. The body of the request must be fully constructed as a valid JSON API payload containing type: "flow-draft", id matching the flowId, and attributes. CRITICAL: All edges with mappers MUST follow the JSONata mapping rules (use $getPassthrough().step_id.body.field for variables, and use double quotes (escaped as \\") for literals without wrapping the entire expression in outer quotes).\n\nPreconditions (Playbook B — all required):\n1. You MUST have called get_flow to inspect the current graph.\n2. The flow MUST be INACTIVE.\n3. You MUST have read the resource elasticio://docs/flow-building-guide.\nPostconditions: Returns the updated draft. The draft must be published (via update_flow or the UI) to take effect.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowId: {
+                    type: 'string',
+                    description: 'The unique identifier of the flow.'
+                },
+                expectedRevision: {
+                    type: 'string',
+                    description: 'The revision string from get_flow_build_status or get_flow. Required for optimistic concurrency control.'
+                },
+                body: {
+                    type: 'object',
+                    description: 'The JSON API compliant PUT request body payload.'
+                }
+            },
+            required: ['flowId', 'body', 'expectedRevision']
+        }
+    },
+    {
+        name: 'get_data_sample',
+        description: 'Retrieve a specific data sample by its ID. Data samples store example input/output data for flow steps, which is used for building mappings between steps.\n\nPreconditions: You MUST have the dataSampleId.\nPostconditions: Returns the data sample with its result body, component, and method.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataSampleId: {
+                    type: 'string',
+                    description: 'The unique identifier of the data sample.'
+                },
+                flowId: {
+                    type: 'string',
+                    description: 'Optional. Flow ID to validate the sample against a specific flow step.'
+                },
+                stepId: {
+                    type: 'string',
+                    description: 'Optional. Step ID within the flow. Required if flowId is provided.'
+                }
+            },
+            required: ['dataSampleId']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.CREATE_DATA_SAMPLE,
+        description: 'Create a new data sample for a component action/trigger. Data samples store example output data for flow steps and are used for building mappings between steps.\n\nPreconditions: You MUST have the componentId and workspaceId. You SHOULD have called get_component to get the correct componentVersion and method (action/trigger name).\nPostconditions: Returns the created data sample with its ID. Link it to a flow step by updating the flow\'s nodes_config with the data_sample_id.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The unique identifier of the workspace.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'The unique identifier of the component.'
+                },
+                componentVersion: {
+                    type: 'string',
+                    description: 'The component version hash (Git revision). Get this from get_component\'s latestVersionId field.'
+                },
+                method: {
+                    type: 'string',
+                    description: 'The action or trigger name (e.g. "receive", "execute", "getUpdatedObjectsPolling").'
+                },
+                body: {
+                    type: 'object',
+                    description: 'The sample data body — the example output that this step produces. This is placed inside result.body in the API payload.'
+                },
+                flowId: {
+                    type: 'string',
+                    description: 'Optional. Flow ID to attach the sample to a specific flow step.'
+                },
+                stepId: {
+                    type: 'string',
+                    description: 'Optional. Step ID within the flow to attach the sample to. Required if flowId is provided.'
+                },
+                expectedRevision: {
+                    type: 'string',
+                    description: 'Optional. The revision string from get_flow_build_status. Required when flowId and stepId are provided.'
+                }
+            },
+            required: ['workspaceId', 'componentId', 'componentVersion', 'method', 'body']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.UPDATE_DATA_SAMPLE,
+        description: 'Update an existing data sample with new result body data.\n\nPreconditions: You MUST have the dataSampleId from a previous get_data_sample, create_data_sample call, or from the flow\'s nodes_config.\nPostconditions: Returns the updated data sample.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataSampleId: {
+                    type: 'string',
+                    description: 'The unique identifier of the data sample to update.'
+                },
+                body: {
+                    type: 'object',
+                    description: 'The new sample data body. This replaces the existing result.body in the data sample.'
+                }
+            },
+            required: ['dataSampleId', 'body']
+        }
+    },
+    {
+        name: DESTRUCTIVE_TOOL_NAMES.DEBUG_FLOW_STEP,
+        description: 'Execute a single component step in debug mode and return the output synchronously. This triggers a real execution of the component with the provided credentials, configuration, and optional input data. Use this to retrieve a live data sample from a component.\n\nPreconditions: You MUST know the component command (from get_component), credentials ID (from list_credentials/list_secrets), and workspace ID.\nPostconditions: Returns the component execution output (body, headers, etc.). The result can be used as a data sample.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                workspaceId: {
+                    type: 'string',
+                    description: 'The workspace ID where the flow will be debugged.'
+                },
+                command: {
+                    type: 'string',
+                    description: 'The component command in format "owner/repo:action@version" (e.g. "elasticio/webhook:receive@abc123").'
+                },
+                credentialsId: {
+                    type: 'string',
+                    description: 'The credentials ID to use for the component (optional for components that do not require auth).'
+                },
+                secretId: {
+                    type: 'string',
+                    description: 'The auth secret ID to use instead of credentials (optional, use either credentialsId or secretId).'
+                },
+                fields: {
+                    type: 'object',
+                    description: 'Optional component configuration fields (key-value pairs).'
+                },
+                sampleData: {
+                    type: 'object',
+                    description: 'Optional input data to pass to the component (simulates incoming message body).'
+                },
+                attachments: {
+                    type: 'object',
+                    description: 'Optional attachments to pass to the component at the message level (simulates msg.attachments). Keys are filenames, values are objects with "url" and "content-type" properties.'
+                },
+                stepId: {
+                    type: 'string',
+                    description: 'Optional step ID to use in the debug flow (e.g. "step_8"). Defaults to "step_1".'
+                },
+                flowId: {
+                    type: 'string',
+                    description: 'Optional. If provided, the debug result will be saved as a data sample and assigned to this step in the flow draft.'
+                },
+                componentId: {
+                    type: 'string',
+                    description: 'Optional. Required together with flowId to save the debug result as a data sample.'
+                },
+                expectedRevision: {
+                    type: 'string',
+                    description: 'Optional. The revision string from get_flow_build_status. Required when flowId is provided.'
+                }
+            },
+            required: ['workspaceId', 'command']
+        }
+    },
+    {
+        name: 'get_session_state',
+        description: 'Retrieve the current session discovery state — which components, credentials, secrets, and flows have been discovered or inspected in this session. Use this tool when you are unsure about what has already been discovered or need to verify preconditions before calling another tool.\n\nPreconditions: None — this tool can be called at any time.\nPostconditions: Returns the current session state. Use this to verify that all preconditions are met before calling create_flow, update_flow, or other tools that require prior discovery.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: []
+        }
+    },
+];
+export const TOOLS = withConfirmationSchemas(TOOL_DEFS);
+//# sourceMappingURL=definitions.js.map