Nós de Ação

Nós programáticos não-LLM para operações de fluxo de trabalho determinísticas. Os nós de ação complementam os agentes LLM ao lidar com transformação de dados, integrações de API, fluxo de controle e lógica de automação.

Visão Geral

Os nós de ação são visualmente distintos dos nós de agente LLM — eles usam cores e ícones únicos para facilitar a leitura dos fluxos de trabalho. Cada tipo de nó lida com uma categoria específica de operação, desde requisições HTTP até consultas a banco de dados e ramificação condicional.

Todos os nós de ação compartilham um conjunto de propriedades padrão para tratamento de erros, rastreamento, controle de execução e mapeamento de E/S. Eles suportam {{variable}} interpolação em campos de string e recebem automaticamente as saídas dos nós predecessores.

Nós Disponíveis

---

Propriedades Padrão

Cada nó de ação herda estas propriedades compartilhadas:

Identidade

Tratamento de Erros

Rastreamento

Controle de Execução

Mapeamento de Entrada/Saída

Referência de Nós

Nó de Gatilho 🎯

Ponto de entrada do fluxo de trabalho. Todo fluxo de trabalho começa com um Nó de Gatilho. Consulte o Guia de Gatilhos dedicado para detalhes completos.

Nó HTTP 🌐

Faz requisições HTTP para APIs externas com tratamento completo de autenticação, cabeçalho, corpo e resposta.

Configuração:

Exemplo:

{
  "type": "http",
  "name": "Fetch User Data",
  "method": "GET",
  "url": "https://api.example.com/users/{{userId}}",
  "auth": {
    "type": "bearer",
    "bearer": { "token": "{{API_TOKEN}}" }
  },
  "headers": { "Accept": "application/json" },
  "body": { "type": "none" },
  "response": { "type": "json", "jsonPath": "$.data" },
  "errorHandling": { "mode": "retry", "retryCount": 3, "retryDelay": 1000 },
  "mapping": { "outputKey": "userData" }
}

Nó de Definição 📝

Define e manipula variáveis de estado do fluxo de trabalho. Suporta valores literais, expressões e segredos.

Configuração:

Tipos de variáveis: string, number, boolean, json, expression

Variáveis marcadas isSecret: true são mascaradas em registros e na interface do usuário.

Nó de Transformação ⚙️

Transforma dados usando expressões ou operações embutidas.

Tipos de transformação:

Operações integradas: pick, omit, rename, flatten, sort, unique

Alvos de coerção de tipo: string, number, boolean, array, object

Nó Switch 🔀

Ramificação condicional com múltiplas portas de saída. Cada condição mapeia para uma porta de saída separada no nó.

Configuração:

Operadores de condição: eq, neq, gt, lt, gte, lte, contains, startsWith, endsWith, matches, in, empty, exists

Exemplo:

{
  "type": "switch",
  "evaluationMode": "first_match",
  "conditions": [
    { "id": "ok", "name": "Success", "field": "status", "operator": "eq", "value": "success", "outputPort": "success" },
    { "id": "err", "name": "Error", "field": "status", "operator": "eq", "value": "error", "outputPort": "error" }
  ],
  "defaultBranch": "unknown"
}

Nó de Loop 🔄

Itera sobre arrays, repete um número fixo de vezes ou faz um loop enquanto uma condição for verdadeira.

Tipos de loop:

Execução paralela: Habilite parallel.enabled com opcionais batchSize e delayBetween para iteração concorrente.

Agregação de resultados: Quando results.collect for verdadeiro, os resultados da iteração são coletados em um array sob results.aggregationKey.

Nó de Fusão 🔗

Combina múltiplas ramificações paralelas de volta em um único fluxo. Possui múltiplas portas de entrada.

Modos de fusão:

Combinar estratégias: array, object, first, last

Tempo limite opcional com comportamento de continue ou error.

Nó de Espera ⏱️

Pausa a execução do fluxo de trabalho.

Tipos de espera:

Nó de Código 💻

Executa JavaScript personalizado em um runtime isolado boa_engine. O estado do grafo é injetado como o objeto global input.

Configuração:

Padrões do Sandbox:

Nó de Banco de Dados 🗄️

Realiza operações de banco de dados com pool de conexões e consultas parametrizadas.

Bancos de dados suportados:

Strings de conexão são tratadas como segredos e mascaradas em logs.

Nó de E-mail 📧

Envia e-mails via SMTP ou monitora e-mails recebidos via IMAP.

Modo de envio (SMTP):

• Suporte a TLS/SSL
• Autenticação
• Destinatários Para/CC/BCC
• Corpo em HTML ou texto simples
• {{variable}} interpolação no assunto e corpo
• Anexos de arquivo do estado

Modo de monitoramento (IMAP):

• Seleção de pasta (padrão: INBOX)
• Filtros: remetente, assunto, intervalo de datas, somente não lidos
• Marcar como lido após o processamento

Nó de Notificação 🔔

Envia notificações para plataformas de mensagens.

Canais: Slack, Discord, Microsoft Teams, webhook personalizado

Formatos de mensagem: texto simples, markdown, blocos específicos da plataforma (Block Kit, Embeds, Adaptive Cards)

Nó RSS 📡

Monitora feeds RSS/Atom para novas entradas.

• Intervalo de sondagem configurável
• Filtros por palavra-chave, autor, categoria e data
• Rastreamento de itens vistos para evitar duplicatas
• Conteúdo completo ou apenas resumo opcional

Nó de Arquivo 📁

Operações de arquivo em armazenamento local ou na nuvem.

Operações: ler, escrever, excluir, listar

Provedores de nuvem: Amazon S3, Google Cloud Storage, Azure Blob Storage

Formatos de arquivo: JSON, CSV, XML, texto, binário (com opções de análise CSV para delimitador, cabeçalhos, aspas)

---

Interpolação de Variáveis

Todos os campos de string em nós de ação suportam a sintaxe {{variable}} para valores dinâmicos:

https://api.example.com/users/{{userId}}
Bearer {{API_TOKEN}}
Hello {{user.name}}, your order {{orderId}} is ready.

As variáveis são resolvidas a partir do estado do fluxo de trabalho no momento da execução. A notação de ponto (user.name) acessa valores aninhados.

Nós Multi-Portas

Dois tipos de nós têm contagens de portas dinâmicas:

• Switch — uma porta de saída por condição, mais uma porta padrão opcional
• Merge — múltiplas portas de entrada, uma por ramificação de entrada

Essas portas são representadas visualmente no nó e conectam-se a diferentes nós a jusante/a montante.

---

Geração de Código

Nós de ação compilam para código Rust de produção juntamente com LLM agents. As dependências são detectadas automaticamente e adicionadas ao Cargo.toml gerado.

Todo o código gerado usa adk-graph FunctionNode closures com GraphError::NodeExecutionFailed para tratamento de erros.

Exemplo de código gerado (nó HTTP):

let http_node = FunctionNode::new("fetch_data", |ctx| async move {
    let client = reqwest::Client::new();
    let resp = client.get("https://api.example.com/data")
        .bearer_auth(&ctx.get("API_TOKEN").unwrap_or_default())
        .send().await
        .map_err(|e| GraphError::NodeExecutionFailed {
            node: "fetch_data".into(),
            message: e.to_string(),
        })?;
    let body: serde_json::Value = resp.json().await?;
    Ok(NodeOutput::new().with_update("apiData", body))
});

Exemplo de código gerado (nó de Código):

let code_node = FunctionNode::new("process", |ctx| async move {
    let mut js_ctx = boa_engine::Context::default();
    // Graph state injected as global `input` object
    // User code executed in thread-isolated sandbox
    Ok(NodeOutput::new().with_update("result", output))
});

---

Anterior: ← Studio | Próximo: Triggers →