flowchart TD
    subgraph "Trigger Nodes"
        T1[trigger:manual]
        T2[trigger:schedule]
        T3[trigger:webhook]
        T4[trigger:event]
    end

    subgraph "Action Nodes"
        A1[action:http]
        A2[action:database]
        A3[action:file]
        A4[action:notification]
        A5[action:code]
        A6[action:user-input]
    end

    subgraph "Agent Nodes"
        AG1[agent:analysis]
        AG2[agent:code-fixer]
        AG3[agent:test-generator]
        AG4[agent:browser]
        AG5[agent:documentation]
        AG6[agent:autonomous]
    end

    subgraph "Flow Control"
        F1[flow:condition]
        F2[flow:switch]
        F3[flow:loop]
        F4[flow:parallel]
        F5[flow:wait]
        F6[flow:error-handler]
    end

    style T1 fill:#e3f2fd
    style A1 fill:#e8f5e9
    style AG1 fill:#fff3e0
    style F1 fill:#fce4ec

flowchart LR
    USER[User Action] --> MANUAL[Manual Trigger]
    MANUAL --> INPUT[Process Input]
    INPUT --> START[Start Workflow]

    style MANUAL fill:#e3f2fd

flowchart LR
    CRON[Cron Expression] --> SCHEDULER[Scheduler]
    SCHEDULER --> CHECK{Time Matches?}
    CHECK -->|Yes| TRIGGER[Schedule Trigger]
    CHECK -->|No| WAIT[Wait]
    WAIT --> CHECK
    TRIGGER --> START[Start Workflow]

    style TRIGGER fill:#e3f2fd

sequenceDiagram
    participant External as External System
    participant Webhook as Webhook Endpoint
    participant Trigger as Webhook Trigger
    participant Engine as Workflow Engine

    External->>Webhook: POST /webhook/{path}
    Webhook->>Webhook: Validate request
    Webhook->>Trigger: Process webhook data
    Trigger->>Engine: Start workflow with payload
    Engine-->>Webhook: Execution ID
    Webhook-->>External: 200 OK

flowchart LR
    EVENT[Application Event] --> BUS[Event Bus]
    BUS --> MATCH{Matches Pattern?}
    MATCH -->|Yes| TRIGGER[Event Trigger]
    MATCH -->|No| IGNORE[Ignore]
    TRIGGER --> START[Start Workflow]

    style TRIGGER fill:#e3f2fd

flowchart TD
    CONFIG[HTTP Config] --> BUILD[Build Request]

    BUILD --> METHOD[Method: GET/POST/PUT/DELETE]
    BUILD --> URL[URL with Variables]
    BUILD --> HEADERS[Headers]
    BUILD --> BODY[Body/Payload]

    METHOD --> SEND[Send Request]
    URL --> SEND
    HEADERS --> SEND
    BODY --> SEND

    SEND --> RESPONSE{Response}
    RESPONSE -->|Success| OUTPUT[Output: Response Data]
    RESPONSE -->|Error| RETRY[Retry/Error]

    style CONFIG fill:#e8f5e9

flowchart TD
    OP[Operation Type] --> SELECT{Operation}

    SELECT -->|Query| QUERY[Run Query]
    SELECT -->|Insert| INSERT[Insert Record]
    SELECT -->|Update| UPDATE[Update Records]
    SELECT -->|Delete| DELETE[Delete Records]

    QUERY --> RESULT[Return Results]
    INSERT --> RESULT
    UPDATE --> RESULT
    DELETE --> RESULT

    style OP fill:#e8f5e9

flowchart TD
    CODE[JavaScript Code] --> SANDBOX[Sandboxed Environment]

    SANDBOX --> CONTEXT[Inject Context]
    CONTEXT --> EXECUTE[Execute Code]

    EXECUTE --> RESULT{Result}
    RESULT -->|Return Value| OUTPUT[Output]
    RESULT -->|Error| ERROR[Error Output]
    RESULT -->|Timeout| TIMEOUT[Timeout Error]

    style CODE fill:#e8f5e9

flowchart TD
    SCHEMA[Input Schema] --> FORM[Generate Form]
    FORM --> PAUSE[Pause Execution]
    PAUSE --> WAIT[Wait for Input]

    WAIT --> USER[User Provides Input]
    USER --> VALIDATE{Valid?}

    VALIDATE -->|Yes| RESUME[Resume Execution]
    VALIDATE -->|No| FORM

    RESUME --> OUTPUT[Output: User Data]

    style PAUSE fill:#fff3e0

flowchart TD
    INPUT[Data Input] --> AGENT[Analysis Agent]

    AGENT --> CONTEXT[Build Context]
    CONTEXT --> LLM[Send to LLM]

    LLM --> ANALYZE[Analyze Data]
    ANALYZE --> INSIGHTS[Generate Insights]
    INSIGHTS --> STRUCT[Structure Output]

    STRUCT --> OUTPUT[Analysis Result]

    style AGENT fill:#fff3e0

sequenceDiagram
    participant Node as Code Fixer Node
    participant Registry as Agent Registry
    participant Agent as Code Fixer Agent
    participant LLM as LLM Provider

    Node->>Registry: getAgent("code-fixer")
    Registry-->>Node: Agent instance

    Node->>Agent: execute({code, error})
    Agent->>Agent: Analyze error context
    Agent->>LLM: Generate fix suggestion
    LLM-->>Agent: Fixed code

    Agent->>Agent: Validate fix
    Agent-->>Node: {fixedCode, explanation}

flowchart TD
    TASK[Browser Task] --> AGENT[Browser Agent]

    AGENT --> LAUNCH[Launch Browser]
    LAUNCH --> NAVIGATE[Navigate to URL]

    NAVIGATE --> ACTIONS{Actions}
    ACTIONS --> CLICK[Click Elements]
    ACTIONS --> TYPE[Type Text]
    ACTIONS --> SCROLL[Scroll Page]
    ACTIONS --> EXTRACT[Extract Data]
    ACTIONS --> SCREENSHOT[Take Screenshot]

    CLICK --> NEXT{More Actions?}
    TYPE --> NEXT
    SCROLL --> NEXT
    EXTRACT --> NEXT
    SCREENSHOT --> NEXT

    NEXT -->|Yes| ACTIONS
    NEXT -->|No| CLOSE[Close Browser]

    CLOSE --> OUTPUT[Extracted Data]

    style AGENT fill:#fff3e0

flowchart TD
    GOAL[High-Level Goal] --> AGENT[Autonomous Agent]

    AGENT --> PLAN[Create Plan]
    PLAN --> STEPS[Break into Steps]

    STEPS --> LOOP{Steps Remaining?}
    LOOP -->|Yes| EXECUTE[Execute Step]
    EXECUTE --> EVALUATE[Evaluate Result]

    EVALUATE --> ADJUST{Need Adjustment?}
    ADJUST -->|Yes| REPLAN[Adjust Plan]
    REPLAN --> LOOP
    ADJUST -->|No| LOOP

    LOOP -->|No| COMPLETE[Goal Complete]

    style AGENT fill:#fff3e0

flowchart TD
    INPUT[Input Data] --> CONDITION[Condition Node]

    CONDITION --> EVAL[Evaluate Expression]
    EVAL --> RESULT{Result}

    RESULT -->|True| TRUE_PATH[True Path]
    RESULT -->|False| FALSE_PATH[False Path]

    style CONDITION fill:#fce4ec

flowchart TD
    VALUE[Input Value] --> SWITCH[Switch Node]

    SWITCH --> MATCH{Match Cases}
    MATCH -->|Case A| PATH_A[Path A]
    MATCH -->|Case B| PATH_B[Path B]
    MATCH -->|Case C| PATH_C[Path C]
    MATCH -->|Default| DEFAULT[Default Path]

    style SWITCH fill:#fce4ec

flowchart TD
    ITEMS[Array Input] --> LOOP[Loop Node]

    LOOP --> ITERATE{More Items?}
    ITERATE -->|Yes| PROCESS[Process Item]
    PROCESS --> BODY[Execute Loop Body]
    BODY --> COLLECT[Collect Result]
    COLLECT --> ITERATE

    ITERATE -->|No| OUTPUT[Array of Results]

    style LOOP fill:#fce4ec

flowchart TD
    INPUT[Input] --> PARALLEL[Parallel Node]

    PARALLEL --> BRANCH1[Branch 1]
    PARALLEL --> BRANCH2[Branch 2]
    PARALLEL --> BRANCH3[Branch 3]

    BRANCH1 --> JOIN[Join Results]
    BRANCH2 --> JOIN
    BRANCH3 --> JOIN

    JOIN --> OUTPUT[Combined Output]

    style PARALLEL fill:#fce4ec

flowchart TD
    TRIGGER[Wait Triggered] --> TYPE{Wait Type}

    TYPE -->|Duration| TIMER[Start Timer]
    TYPE -->|Until Date| SCHEDULE[Schedule Wake]
    TYPE -->|For Event| LISTEN[Listen for Event]

    TIMER --> WAIT[Waiting...]
    SCHEDULE --> WAIT
    LISTEN --> WAIT

    WAIT --> RESUME[Resume Execution]

    style WAIT fill:#fce4ec

flowchart TD
    TRY[Try Block] --> EXECUTE[Execute Nodes]

    EXECUTE --> RESULT{Result}
    RESULT -->|Success| SUCCESS[Continue]
    RESULT -->|Error| CATCH[Error Handler]

    CATCH --> HANDLE[Handle Error]
    HANDLE --> STRATEGY{Strategy}

    STRATEGY -->|Retry| RETRY[Retry Execution]
    STRATEGY -->|Fallback| FALLBACK[Execute Fallback]
    STRATEGY -->|Rethrow| RETHROW[Propagate Error]

    RETRY --> EXECUTE
    FALLBACK --> CONTINUE[Continue Workflow]

    style CATCH fill:#fce4ec

erDiagram
    NODE ||--o{ INPUT_PORT : has
    NODE ||--o{ OUTPUT_PORT : has
    NODE ||--|| NODE_CONFIG : configures

    NODE {
        string id PK
        string type
        string label
        json position
        json data
    }

    INPUT_PORT {
        string id PK
        string nodeId FK
        string name
        string dataType
        boolean required
    }

    OUTPUT_PORT {
        string id PK
        string nodeId FK
        string name
        string dataType
    }

    NODE_CONFIG {
        string nodeId FK
        json settings
        json credentials
        json validation
    }