Method execute_agent_node_static

core/src/workflow.rs:1435–2055

Execute an agent node (static version). When `guardrail_enforcer` is `Some`, encodes prompt before LLM and decodes response after. When `stream_mode.emits_tokens()` and the provider supports streaming, emits `Token` events per chunk via `event_tx` and accumulates into a full response. Falls back to `complete()` if the provider does not support streaming.

(
        current_node_id: &NodeId,
        agent_node_config: &AgentNodeConfig,
        node_config: &std::collections::HashMap<String, serde_json::Value>,
        context: Arc<Mutex<WorkflowContext>

    /// events per chunk via `event_tx` and accumulates into a full response. Falls back to
    /// `complete()` if the provider does not support streaming.
    async fn execute_agent_node_static(
        current_node_id: &NodeId,
        agent_node_config: &AgentNodeConfig,
        node_config: &std::collections::HashMap<String, serde_json::Value>,
        context: Arc<Mutex<WorkflowContext>>,
        agents: Arc<RwLock<HashMap<crate::types::AgentId, Arc<dyn AgentTrait>>>>,
        guardrail_enforcer: Option<Arc<Enforcer>>,
        event_tx: Option<tokio::sync::mpsc::Sender<crate::stream::StreamEvent>>,
        stream_mode: crate::stream::StreamMode,
    ) -> GraphBitResult<serde_json::Value> {
        let agent_id = &agent_node_config.agent_id;
        let prompt_template = &agent_node_config.prompt_template;
        let conversational_context = agent_node_config.conversational_context.as_deref();
        // Use read lock for better performance
        let agents_guard = agents.read().await;
        let agent = agents_guard
            .get(agent_id)
            .ok_or_else(|| GraphBitError::agent_not_found(agent_id.to_string()))?
            .clone();
        drop(agents_guard); // Release the lock early

        // Build implicit preamble from upstream (parent) node outputs, then resolve templates
        let (resolved_prompt, resolved_context, metadata_input_raw) = {
            let ctx = context.lock().await;

            // Extract dependency map and name map from metadata
            let deps_map = ctx
                .metadata
                .get("node_dependencies")
                .cloned()
                .unwrap_or(serde_json::json!({}));
            let id_name_map = ctx
                .metadata
                .get("node_id_to_name")
                .cloned()
                .unwrap_or(serde_json::json!({}));

            // Collect preamble sections from DIRECT parents of this node
            let mut sections: Vec<String> = Vec::new();
            // Also collect a JSON map of parent outputs for CrewAI-style context passing
            let mut parents_json: serde_json::Map<String, serde_json::Value> =
                serde_json::Map::new();

            // Use id->name map for titles
            let id_name_obj = id_name_map.as_object();

            // Resolve current node id string and direct parents from deps map
            let cur_id_str = current_node_id.to_string();
            let parent_ids: Vec<String> = deps_map
                .as_object()
                .and_then(|m| m.get(&cur_id_str))
                .and_then(|v| v.as_array())
                .map(|arr| {
                    arr.iter()
                        .filter_map(|v| v.as_str().map(str::to_string))
                        .collect::<Vec<String>>()
                })
                .unwrap_or_default();