Aktionsknoten

Der adk-action-Crate definiert 14 Aktionsknotentypen, die in graphbasierten Workflows verwendet werden. Jeder Knotentyp stellt eine diskrete Operation dar (HTTP-Aufruf, Datentransformation, bedingte Verzweigung usw.), die über ActionNodeExecutor von adk-graph zu gerichteten Graphen zusammengesetzt werden kann.

Übersicht

Aktionsknoten sind die Bausteine visueller und programmgesteuerter Workflow-Graphen. Sie bieten:

• Typisierte Operationen — 14 Knotentypen für gängige Workflow-Muster
• StandardProperties — Gemeinsame Konfiguration für Fehlerbehandlung, Tracing und Datenzuordnung
• Variableninterpolation — {{variable}}-Syntax für dynamische Werte
• Graphintegration — Ausgeführt durch ActionNodeExecutor von adk-graph

Installation

[dependencies]
adk-action = "2.1.0"

# Or specific action features via umbrella crate
adk-rust = { version = "2.1.0", features = ["action"] }

Knotentypen (14)

Verfügbarkeit wird beim Erstellen des Graphen geprüft

Einige Knotentypen akzeptieren und validieren eine Konfiguration, obwohl ihr Backend nicht vorhanden ist.
Diese werden von StateGraph::compile() abgelehnt, nicht erst mitten in einem Durchlauf:

Eine Ablehnung nennt den Knoten und den Grund, sodass ein Workflow, der nicht ausgeführt werden kann, bereits beim Zusammenstellen fehlschlägt und nicht erst, nachdem frühere Knoten bereits Seiteneffekte verursacht haben.

Implementieren Sie Node::validate in einem benutzerdefinierten Knoten, damit er an derselben Prüfung teilnimmt.

StandardProperties

Jeder Aktionsknoten enthält StandardProperties — eine gemeinsame Konfiguration, die das Ausführungsverhalten steuert:

use adk_action::{StandardProperties, ErrorHandling, RetryConfig};

let props = StandardProperties::builder()
    // Error handling
    .on_error(ErrorHandling::ContinueOnFail)
    .retry(RetryConfig {
        max_attempts: 3,
        wait_between_ms: 1000,
    })

    // Tracing
    .notes("Fetch user profile from API")

    // Callbacks
    .on_success("notify_complete")
    .on_failure("alert_team")

    // Execution
    .timeout_ms(30_000)
    .continue_on_fail(true)

    // Input/output mapping
    .input_mapping("{{trigger.body.user_id}}")
    .output_key("user_profile")

    .build();

StandardProperties Felder

Variableninterpolation

Aktionsknoten unterstützen die Syntax {{variable}} zum Referenzieren des Workflow-Zustands:

use adk_action::HttpNode;

let node = HttpNode::builder()
    .url("https://api.example.com/users/{{trigger.body.user_id}}")
    .method("GET")
    .headers(vec![
        ("Authorization".into(), "Bearer {{env.API_TOKEN}}".into()),
    ])
    .build();

Variablenquellen

Verschachtelter Zugriff verwendet die Punktnotation: {{nodes.http_1.json.data[0].id}}

Knotenbeispiele

HTTP-Knoten

use adk_action::{HttpNode, HttpMethod};

let node = HttpNode::builder()
    .method(HttpMethod::Post)
    .url("https://api.example.com/orders")
    .headers(vec![
        ("Content-Type".into(), "application/json".into()),
    ])
    .body(r#"{"item": "{{trigger.body.item}}", "qty": {{trigger.body.quantity}}}"#)
    .properties(StandardProperties::builder()
        .timeout_ms(10_000)
        .on_error(ErrorHandling::RetryThenFail)
        .retry(RetryConfig { max_attempts: 3, wait_between_ms: 2000 })
        .output_key("order_response")
        .build())
    .build();

Verzweigungsknoten

use adk_action::{SwitchNode, SwitchCase};

let node = SwitchNode::builder()
    .cases(vec![
        SwitchCase {
            condition: "{{nodes.classify.json.category}} == 'urgent'".into(),
            output: "urgent_path".into(),
        },
        SwitchCase {
            condition: "{{nodes.classify.json.category}} == 'normal'".into(),
            output: "normal_path".into(),
        },
    ])
    .fallback("default_path")
    .build();

Schleifenknoten

use adk_action::{LoopNode, LoopMode};

let node = LoopNode::builder()
    .mode(LoopMode::ForEach {
        items: "{{nodes.fetch_users.json.users}}".into(),
        item_var: "current_user".into(),
    })
    .body_nodes(vec!["process_user", "save_result"])
    .properties(StandardProperties::builder()
        .notes("Process each user in the list")
        .build())
    .build();

Set-Knoten

use adk_action::SetNode;

let node = SetNode::builder()
    .assignments(vec![
        ("status".into(), "processing".into()),
        ("started_at".into(), "{{workflow.timestamp}}".into()),
        ("user_email".into(), "{{trigger.body.email}}".into()),
    ])
    .build();

Integration mit adk-graph

Aktionsknoten werden von adk-graphs ActionNodeExecutor ausgeführt:

use adk_graph::{Graph, ActionNodeExecutor};
use adk_action::{TriggerNode, HttpNode, SetNode};

// Define nodes
let trigger = TriggerNode::webhook("order_received");
let fetch = HttpNode::get("https://api.example.com/inventory/{{trigger.body.sku}}");
let update = SetNode::new(vec![("available", "{{nodes.fetch.json.quantity}}")]);

// Build graph
let graph = Graph::builder()
    .node("trigger", trigger)
    .node("check_inventory", fetch)
    .node("update_status", update)
    .edge("trigger", "check_inventory")
    .edge("check_inventory", "update_status")
    .build()?;

// Execute
let executor = ActionNodeExecutor::new();
let result = executor.run(graph, initial_context).await?;

Benutzerdefinierte Knotentypen definieren

Implementieren Sie das ActionNode-Trait:

use adk_action::{ActionNode, ActionContext, ActionResult, StandardProperties};
use async_trait::async_trait;

struct CustomNode {
    config: MyConfig,
    properties: StandardProperties,
}

#[async_trait]
impl ActionNode for CustomNode {
    fn node_type(&self) -> &str { "custom" }
    fn properties(&self) -> &StandardProperties { &self.properties }

    async fn execute(&self, ctx: &ActionContext) -> ActionResult {
        let input = ctx.resolve("{{trigger.body.data}}")?;
        // Custom logic...
        Ok(serde_json::json!({ "result": "processed" }))
    }
}

Verwandte Themen

• Graph-Agenten — Orchestrierung von Graph-Workflows
• Studio-Aktionsknoten — Visueller Knoten-Editor in ADK Studio
• Trigger — Typen von Workflow-Triggern

---

Zurück: ← Erneut versuchen und reflektieren | Weiter: Plugins →