> ## Documentation Index
> Fetch the complete documentation index at: https://flowdrop.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Get interrupt details

> Retrieve details about a specific interrupt request.
Interrupts are created when a workflow execution requires human input.




## OpenAPI

````yaml /api-reference/openapi.yaml get /interrupts/{interruptId}
openapi: 3.0.3
info:
  title: FlowDrop™ API
  description: >
    FlowDrop is a visual workflow editor for AI applications and data processing
    pipelines.

    This API provides comprehensive endpoints for managing workflows, node
    types, pipeline execution, and port configuration.


    ## Features

    - **Workflow Management**: Complete CRUD operations for workflows with nodes
    and edges

    - **Node Type Discovery**: Browse and search available node processors with
    metadata

    - **Pipeline Execution**: Execute workflows with real-time status tracking
    and job management

    - **Port Configuration**: Dynamic port compatibility system with data type
    management

    - **Real-time Updates**: Track node execution status and pipeline progress

    - **Import/Export**: Import and export workflows in JSON format

    - **Validation**: Workflow validation before execution

    - **Agent Spec Integration**: Import/export Oracle Open Agent Spec flows and
    execute on compatible runtimes (WayFlow/PyAgentSpec)


    ## Architecture

    - **Frontend**: Svelte 5 + XYFlow for visual workflow editing

    - **Backend**: Drupal 10/11 with custom node processor plugins

    - **API**: RESTful JSON API with consistent response format

    - **Storage**: Drupal entity system with workflow versioning


    ## Authentication

    API endpoints require Drupal authentication. Use Bearer token or
    session-based authentication.


    ## Rate Limiting

    - Node Discovery: 100 requests/minute

    - Workflow Operations: 50 requests/minute

    - Pipeline Execution: 20 requests/minute


    ## Error Handling

    All errors return a consistent format with success flag, error message, and
    optional details.
  version: 1.0.0
  contact:
    name: FlowDrop Support
    email: shibinkidd@gmail.com
    url: https://www.drupal.org/project/issues/flowdrop?categories=All
servers:
  - url: http://localhost:5173/api/flowdrop
    description: Local development server (Svelte)
  - url: https://flowdrop.ddev.site/api/flowdrop
    description: Local Drupal server
security:
  - BearerAuth: []
  - SessionAuth: []
tags:
  - name: System
    description: System health and status endpoints
  - name: Node Types
    description: Node type discovery and metadata endpoints
  - name: Configuration
    description: System configuration endpoints including port configuration
  - name: Workflows
    description: Workflow CRUD operations
  - name: Pipeline
    description: Pipeline execution and monitoring
  - name: Playground
    description: Interactive workflow testing and chat interface
  - name: Interrupts
    description: |
      Human-in-the-Loop (HITL) interrupt endpoints for workflow interactions.
      Interrupts allow workflows to pause execution and request user input.
  - name: Validation
    description: Workflow validation
  - name: Import/Export
    description: Workflow import and export operations
  - name: Chat
    description: |
      LLM Chat Interface for natural language workflow building.
      Translates user intent into DSL commands via a backend LLM integration.
  - name: Agent Spec
    description: >
      Oracle Open Agent Spec integration endpoints.

      Provides bidirectional conversion between FlowDrop workflows and Agent
      Spec format,

      plus runtime execution on compatible runtimes (WayFlow, PyAgentSpec).

      @see https://github.com/oracle/agent-spec
paths:
  /interrupts/{interruptId}:
    get:
      tags:
        - Interrupts
      summary: Get interrupt details
      description: |
        Retrieve details about a specific interrupt request.
        Interrupts are created when a workflow execution requires human input.
      operationId: getInterrupt
      parameters:
        - name: interruptId
          in: path
          description: Interrupt UUID
          required: true
          schema:
            type: string
            format: uuid
      responses:
        '200':
          description: Interrupt details retrieved successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/InterruptResponse'
        '404':
          $ref: '#/components/responses/NotFound'
        '500':
          $ref: '#/components/responses/InternalServerError'
components:
  schemas:
    InterruptResponse:
      allOf:
        - $ref: '#/components/schemas/ApiResponse'
        - type: object
          properties:
            data:
              $ref: '#/components/schemas/Interrupt'
    ApiResponse:
      type: object
      properties:
        success:
          type: boolean
          description: Whether the request was successful
        data:
          description: Response data (type varies by endpoint)
        message:
          type: string
          description: Response message
        error:
          type: string
          description: Error message (if any)
    Interrupt:
      type: object
      description: |
        Represents a Human-in-the-Loop interrupt request.
        Interrupts are created when workflow execution requires user input.
      properties:
        id:
          type: string
          format: uuid
          description: Interrupt unique identifier
        messageId:
          type: string
          format: uuid
          description: Associated playground message ID
        type:
          $ref: '#/components/schemas/InterruptType'
        status:
          $ref: '#/components/schemas/InterruptStatus'
        nodeId:
          type: string
          description: ID of the node that created the interrupt
        executionId:
          type: string
          description: Workflow execution ID
        config:
          oneOf:
            - $ref: '#/components/schemas/ConfirmationInterruptConfig'
            - $ref: '#/components/schemas/ChoiceInterruptConfig'
            - $ref: '#/components/schemas/TextInterruptConfig'
            - $ref: '#/components/schemas/FormInterruptConfig'
            - $ref: '#/components/schemas/ReviewInterruptConfig'
          description: Type-specific configuration
        allowCancel:
          type: boolean
          default: true
          description: Whether the interrupt can be cancelled
        response:
          description: User's response (set after resolution)
        response_time:
          type: string
          format: date-time
          description: When the interrupt was resolved
        user_id:
          type: string
          description: ID of the user who resolved the interrupt
        createdAt:
          type: string
          format: date-time
          description: When the interrupt was created
      required:
        - id
        - type
        - status
        - nodeId
        - executionId
        - config
        - allowCancel
    ErrorResponse:
      allOf:
        - $ref: '#/components/schemas/ApiResponse'
        - type: object
          properties:
            success:
              type: boolean
              example: false
            error:
              type: string
              description: Error message
            code:
              type: string
              description: Error code
            details:
              type: object
              description: Additional error details
    InterruptType:
      type: string
      enum:
        - confirmation
        - choice
        - text
        - form
        - review
      description: |
        Type of interrupt prompt:
        - `confirmation`: Yes/No approval prompt
        - `choice`: Single or multiple selection from options
        - `text`: Free-form text input
        - `form`: JSON Schema-based form
        - `review`: Review proposed field changes (accept/reject individually)
    InterruptStatus:
      type: string
      enum:
        - pending
        - resolved
        - cancelled
      description: |
        Current status of the interrupt:
        - `pending`: Awaiting user response
        - `resolved`: User submitted a response
        - `cancelled`: Interrupt was cancelled
    ConfirmationInterruptConfig:
      type: object
      description: Configuration for confirmation-type interrupts
      properties:
        message:
          type: string
          description: Prompt message to display
          example: Do you approve this action?
        confirm_label:
          type: string
          description: Label for confirm button
          default: 'Yes'
          example: Approve
        cancel_label:
          type: string
          description: Label for cancel/reject button
          default: 'No'
          example: Reject
      required:
        - message
    ChoiceInterruptConfig:
      type: object
      description: Configuration for choice-type interrupts
      properties:
        message:
          type: string
          description: Prompt message to display
          example: Select your preferred option
        options:
          type: array
          items:
            $ref: '#/components/schemas/ChoiceOption'
          description: Available options to choose from
          minItems: 1
        multiple:
          type: boolean
          default: false
          description: Whether multiple selections are allowed
        min_selections:
          type: integer
          minimum: 0
          description: Minimum number of selections required
        max_selections:
          type: integer
          minimum: 1
          description: Maximum number of selections allowed
      required:
        - message
        - options
    TextInterruptConfig:
      type: object
      description: Configuration for text-type interrupts
      properties:
        message:
          type: string
          description: Prompt message to display
          example: Please provide additional details
        placeholder:
          type: string
          description: Placeholder text for input field
          example: Enter your response...
        multiline:
          type: boolean
          default: false
          description: Whether to use a textarea for multiline input
        min_length:
          type: integer
          minimum: 0
          description: Minimum text length required
        max_length:
          type: integer
          minimum: 1
          description: Maximum text length allowed
        default_value:
          type: string
          description: Default value to pre-fill
      required:
        - message
    FormInterruptConfig:
      type: object
      description: Configuration for form-type interrupts
      properties:
        message:
          type: string
          description: Prompt message to display above the form
          example: Please fill in the required information
        schema:
          $ref: '#/components/schemas/ConfigSchema'
          description: JSON Schema defining the form structure
        default_values:
          type: object
          additionalProperties: true
          description: Default values for form fields
      required:
        - message
        - schema
    ReviewInterruptConfig:
      type: object
      description: >-
        Configuration for review-type interrupts. Displays a list of proposed
        field changes for the user to accept or reject individually.
      properties:
        message:
          type: string
          description: Prompt message to display above the review
          example: Please review the following changes
        changes:
          type: array
          items:
            $ref: '#/components/schemas/ReviewChange'
          description: List of field changes to review
          minItems: 1
        accept_all_label:
          type: string
          description: Label for the "Accept All" button
          default: Accept All
        reject_all_label:
          type: string
          description: Label for the "Reject All" button
          default: Reject All
        submit_label:
          type: string
          description: Label for the submit button
          default: Submit Review
      required:
        - message
        - changes
    ChoiceOption:
      type: object
      description: Option for choice-type interrupts
      properties:
        value:
          type: string
          description: Value to submit when selected
          example: option1
        label:
          type: string
          description: Display label for the option
          example: Option 1
        description:
          type: string
          description: Optional description for the option
          example: This is the first option
      required:
        - value
        - label
    ConfigSchema:
      type: object
      properties:
        type:
          type: string
          enum:
            - object
        properties:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/ConfigProperty'
          description: Configuration properties
        required:
          type: array
          items:
            type: string
          description: Required property names
        additionalProperties:
          type: boolean
          default: false
      required:
        - type
        - properties
    ReviewChange:
      type: object
      description: A single field change proposed for review
      properties:
        field:
          type: string
          description: Field identifier (machine key)
          example: title
        label:
          type: string
          description: Human-readable field label
          example: Page Title
        original:
          description: Original value before the proposed change
          example: About Us
        proposed:
          description: Proposed new value
          example: About Our Company
      required:
        - field
        - label
        - original
        - proposed
    ConfigProperty:
      type: object
      description: >
        JSON Schema property definition for node configuration.

        Follows JSON Schema draft-07 specification with FlowDrop extensions for
        UI rendering.


        For select/dropdown fields, use standard JSON Schema patterns:

        - `enum` for simple value lists (no labels)

        - `oneOf` with `const`/`title` for labeled options
      properties:
        type:
          type: string
          enum:
            - string
            - number
            - boolean
            - array
            - object
            - integer
          description: JSON Schema type
        title:
          type: string
          description: Display title for the property
        description:
          type: string
          description: Property description
        default:
          description: Default value for the property
        enum:
          type: array
          items: {}
          description: |
            Allowed values for enum properties (simple values without labels).
            For labeled options, use `oneOf` with `const`/`title` instead.
        oneOf:
          type: array
          items:
            $ref: '#/components/schemas/OneOfItem'
          description: >
            JSON Schema oneOf for labeled options (standard approach).

            Each item should have `const` (value) and optionally `title`
            (label).


            Example:

            ```json

            "oneOf": [
              { "const": "draft", "title": "Draft" },
              { "const": "published", "title": "Published" }
            ]

            ```
        multiple:
          type: boolean
          description: >-
            For enum/oneOf fields, allows multiple selection (renders as
            checkbox group)
        minimum:
          type: number
          description: Minimum value for numeric properties
        maximum:
          type: number
          description: Maximum value for numeric properties
        step:
          type: number
          description: Step increment for number/range inputs
        minLength:
          type: integer
          description: Minimum length for string properties
        maxLength:
          type: integer
          description: Maximum length for string properties
        pattern:
          type: string
          description: Regex pattern for string validation
        placeholder:
          type: string
          description: Placeholder text for input fields
        format:
          type: string
          description: >
            Special format hints for UI rendering:


            - `multiline`: Renders as textarea

            - `hidden`: Field is hidden from UI but included in form submission

            - `range`: Renders as range slider for numeric values

            - `json`: Renders as CodeMirror JSON editor

            - `code`: Alias for json, renders as CodeMirror editor

            - `markdown`: Renders as SimpleMDE Markdown editor

            - `template`: Template editor with variable autocomplete (see below)

            - `autocomplete`: Text input with callback URL suggestions

            - `email`, `uri`, `date`, `date-time`: Standard JSON Schema formats


            ## Template Format Details


            The `template` format renders a CodeMirror editor with:


            **Syntax highlighting** for Twig/Liquid-style `{{ variable }}`
            placeholders


            **Inline autocomplete** triggered by:

            - Typing `{{` - Shows available variables

            - Typing `.` after an object - Shows nested properties

            - Typing `[` after an array - Shows index suggestions


            **Variable patterns supported:**

            - `{{ user }}` - Simple variable

            - `{{ user.name }}` - Nested property access

            - `{{ user.address.city }}` - Deep nesting

            - `{{ items[0] }}` - Array index access

            - `{{ orders[0].product.name }}` - Combined patterns


            **Autocomplete source:**

            Variables are derived from connected upstream nodes that have output

            schemas defined. Use the `variables` property to configure which

            input ports provide variables.
          enum:
            - multiline
            - hidden
            - range
            - json
            - code
            - markdown
            - template
            - autocomplete
            - email
            - uri
            - date
            - date-time
        variables:
          $ref: '#/components/schemas/TemplateVariablesConfig'
          description: |
            Configuration for template variable autocomplete.
            Only applicable when `format: "template"`.
            See TemplateVariablesConfig for full documentation.
        x-display-order:
          type: integer
          description: >
            Controls the display order of fields in the configuration form.

            Fields are sorted by this value in ascending order (lower values
            appear first).


            Use negative values to ensure fields appear at the top:

            - `-2` for `instanceTitle` (appears first)

            - `-1` for `instanceDescription` (appears second)

            - `0` or positive values for regular fields


            Fields without `x-display-order` are sorted after fields with
            explicit ordering.
          example: -2
        items:
          $ref: '#/components/schemas/ConfigProperty'
          description: Schema for array items
        minItems:
          type: integer
          description: Minimum number of items for array fields
        maxItems:
          type: integer
          description: Maximum number of items for array fields
        properties:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/ConfigProperty'
          description: Property schemas for object fields
        autocomplete:
          $ref: '#/components/schemas/AutocompleteConfig'
          description: >-
            Configuration for autocomplete fields (when format is
            "autocomplete")
        readOnly:
          type: boolean
          description: >
            JSON Schema `readOnly` keyword. When true, the field is displayed
            but

            cannot be edited (rendered in a disabled state).
        height:
          type: string
          description: |
            Editor height as a CSS value (e.g. `200px`).
            Applies to editor fields: `json`/`code`, `markdown`, and `template`.
            Defaults: `200px` (code), `300px` (markdown), `250px` (template).
          example: 300px
        darkTheme:
          type: boolean
          description: |
            Force the editor's dark theme on or off.
            Applies to `json`/`code` and `template` fields.
            When omitted, the editor follows the resolved app theme.
        autoFormat:
          type: boolean
          default: true
          description: |
            Whether to auto-format JSON on blur.
            Applies to `json`/`code` editor fields.
        showToolbar:
          type: boolean
          default: true
          description: |
            Whether to show the editor toolbar.
            Applies to `markdown` editor fields.
        showStatusBar:
          type: boolean
          default: true
          description: |
            Whether to show the editor status bar.
            Applies to `markdown` editor fields.
        spellChecker:
          type: boolean
          default: false
          description: |
            Whether to enable spell checking.
            Applies to `markdown` editor fields.
        placeholderExample:
          type: string
          description: |
            Example template string shown as a placeholder hint.
            Applies to `template` fields.
          example: 'Hello {{ name }}, your order #{{ order_id }} is ready!'
      required:
        - type
    OneOfItem:
      type: object
      description: |
        JSON Schema oneOf item for labeled options.
        This is the standard JSON Schema way to define labeled select options.

        Example:
        ```json
        {
          "type": "string",
          "oneOf": [
            { "const": "draft", "title": "Draft" },
            { "const": "published", "title": "Published" }
          ]
        }
        ```
      properties:
        const:
          oneOf:
            - type: string
            - type: number
            - type: boolean
          description: The constant value for this option (JSON Schema `const` keyword)
        title:
          type: string
          description: Human-readable label for this option
        description:
          type: string
          description: Optional description for this option
      required:
        - const
    TemplateVariablesConfig:
      type: object
      description: >
        Configuration for template variable autocomplete in template fields.


        ## Overview


        When a template field is connected to upstream nodes that have output
        schemas,

        FlowDrop automatically derives available variables for autocomplete.
        This config

        controls which ports provide variables and how they are presented.


        ## Variable Derivation


        Variables are derived from connected upstream nodes' **output port
        schemas**.

        When an output port has a `schema` property with `properties`, those
        properties

        become available as template variables.


        ### Default Behavior (includePortName: false)


        Schema properties are **unpacked as top-level variables**:


        ```

        HTTP Request node (output port "json" with schema):
          schema.properties: { user: {...}, orders: {...} }
                                  ↓
        Template variables: {{ user }}, {{ orders }}

        ```


        ### With includePortName: true


        Variables are **prefixed with the port name**:


        ```

        Same schema as above:
                                  ↓
        Template variables: {{ data.user }}, {{ data.orders }}

        ```


        ## Nested Property Access


        The autocomplete supports drilling into nested structures:


        - **Dot notation**: `{{ user.address.city }}`

        - **Array indices**: `{{ orders[0].product_name }}`

        - **Combined**: `{{ user.orders[0].items[1].price }}`
      properties:
        ports:
          type: array
          items:
            type: string
          description: >
            Specifies which input port IDs should provide variables for
            autocomplete.

            Only connections to these ports will contribute variables.


            **Behavior:**

            - If not specified: All input ports with connections are used

            - If empty array `[]`: No variables derived from ports (use with
            `schema` for static variables)

            - If specified: Only the listed ports contribute variables


            **Example:** A node with inputs "data", "context", and "trigger":

            - `ports: ["data"]` - Only variables from the "data" connection

            - `ports: ["data", "context"]` - Variables from both connections

            - Not specified - Variables from all non-trigger connections
          example:
            - data
            - context
        schema:
          $ref: '#/components/schemas/VariableSchema'
          description: >
            Pre-defined variable schema to provide static variables or override
            derived ones.


            When both `ports` and `schema` are specified, variables are
            **merged**:

            - Variables from connected ports are computed first

            - Static `schema` variables are added/override existing ones


            **Use cases:**

            - Provide variables that don't come from connections

            - Override labels or descriptions for derived variables

            - Add custom variables for specific use cases
        includePortName:
          type: boolean
          default: false
          description: |
            Controls how variables are named when derived from port schemas.

            **When false (default):**
            Schema properties become top-level variables directly.
            A port with schema `{ user: {...}, orders: {...} }` produces:
            - `{{ user }}`
            - `{{ orders }}`

            **When true:**
            Variables are prefixed with the input port name.
            Same schema connected to input port "data" produces:
            - `{{ data.user }}`
            - `{{ data.orders }}`

            **When to use true:**
            - Multiple input ports with potentially overlapping property names
            - You want to be explicit about data sources in templates
            - Backward compatibility with existing templates
        showHints:
          type: boolean
          default: true
          description: >
            Whether to display clickable variable hints below the editor.


            When enabled, shows a row of buttons for top-level variables that
            users

            can click to insert `{{ variableName }}` at the cursor position.


            Disable if the variable list is too long or not useful.
      example:
        ports:
          - data
        showHints: true
        includePortName: false
    AutocompleteConfig:
      type: object
      description: >
        Configuration for autocomplete fields that fetch suggestions from a
        callback URL.

        Used when format is "autocomplete".
      properties:
        url:
          type: string
          description: |
            The callback URL to fetch autocomplete suggestions from.
            Can be relative (resolved against API base URL) or absolute.
          example: /api/users/search
        queryParam:
          type: string
          default: q
          description: Query parameter name to pass the search term
        minChars:
          type: integer
          default: 0
          description: |
            Minimum number of characters before fetching suggestions.
            Set to 0 to fetch immediately on focus (when fetchOnFocus is true).
        debounceMs:
          type: integer
          default: 300
          description: Debounce delay in milliseconds before fetching suggestions
        fetchOnFocus:
          type: boolean
          default: false
          description: Whether to fetch all options when the field is focused
        labelField:
          type: string
          default: label
          description: The field name in the response objects to use as the display label
        valueField:
          type: string
          default: value
          description: The field name in the response objects to use as the stored value
        allowFreeText:
          type: boolean
          default: false
          description: |
            Whether to allow values that are not in the suggestions list.
            When true, users can enter and submit any text.
        multiple:
          type: boolean
          default: false
          description: |
            Whether to allow multiple selections.
            When true, users can select multiple values displayed as tags.
        params:
          type: object
          additionalProperties:
            type: string
          description: |
            Map of URL query parameter names to sibling form field names.
            When fetching autocomplete options, the current value of each
            referenced sibling field is appended as a query parameter.
            When any dependency field changes, the autocomplete clears its
            current value and invalidates the suggestion cache.
      required:
        - url
    VariableSchema:
      type: object
      description: |
        Schema passed to template editor for autocomplete functionality.
        Contains all available variables derived from connected upstream nodes.

        This is computed by the frontend based on:
        1. Finding all edges that connect to the current node's input ports
        2. Getting the output schemas from the source nodes' output ports
        3. Building a hierarchical variable structure for autocomplete
      properties:
        variables:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/TemplateVariable'
          description: Map of available variables keyed by variable name
      required:
        - variables
      example:
        variables:
          user:
            name: user
            type: object
            label: User Data
            properties:
              name:
                name: name
                type: string
              email:
                name: email
                type: string
          items:
            name: items
            type: array
            label: Order Items
            items:
              name: item
              type: object
              properties:
                product_name:
                  name: product_name
                  type: string
                price:
                  name: price
                  type: number
    TemplateVariable:
      type: object
      description: |
        Represents a variable available for template interpolation.
        Used by the template editor for autocomplete suggestions.

        Supports hierarchical drilling:
        - Objects have `properties` for dot notation (e.g., `user.name`)
        - Arrays have `items` for index access (e.g., `items[0].name`)
      properties:
        name:
          type: string
          description: Variable name (used in template as {{ name }})
          example: user
        label:
          type: string
          description: Display label for the variable in autocomplete dropdown
          example: User Data
        description:
          type: string
          description: Description shown in autocomplete tooltip
          example: User information from upstream node
        type:
          type: string
          enum:
            - string
            - number
            - integer
            - boolean
            - array
            - object
            - float
            - mixed
          description: Data type of the variable
        properties:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/TemplateVariable'
          description: For objects - child properties accessible via dot notation
        items:
          $ref: '#/components/schemas/TemplateVariable'
          description: For arrays - schema of array items accessible via index notation
        sourcePort:
          type: string
          description: Source port ID this variable comes from
        sourceNode:
          type: string
          description: Source node ID
      required:
        - name
        - type
      example:
        name: user
        label: User Data
        type: object
        properties:
          name:
            name: name
            type: string
            label: User Name
          email:
            name: email
            type: string
            label: Email Address
          address:
            name: address
            type: object
            label: Address
            properties:
              city:
                name: city
                type: string
                label: City
              country:
                name: country
                type: string
                label: Country
  responses:
    NotFound:
      description: Resource not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            success: false
            error: Resource not found
            code: NOT_FOUND
    InternalServerError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorResponse'
          example:
            success: false
            error: Internal server error
            code: INTERNAL_ERROR
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: JWT token for authentication
    SessionAuth:
      type: apiKey
      in: cookie
      name: SESS
      description: Drupal session cookie

````