Method execute_agent_with_tools

core/src/workflow.rs:2068–2603

Execute an agent with tool calling orchestration. When `guardrail_enforcer` is `Some`, encodes prompt before LLM and decodes response after. When `stream_mode.emits_tool_events()` and `event_tx` is `Some`, emits `ToolCallStarted` for each tool call requested by the LLM before returning the `tool_calls_required` response to the Python layer (which handles actual execution and must emit `ToolCallCom

(
        _agent_id: &crate::types::AgentId,
        agent_node_config: &AgentNodeConfig,
        prompt: &str,
        conversational_context: Option<&str>,
        metadata_input: &str,
        node

    /// [`crate::stream::StreamEvent::Token`] per chunk; otherwise that call uses
    /// [`LlmProvider::complete`] (same as non-streaming `execute()`).
    async fn execute_agent_with_tools(
        _agent_id: &crate::types::AgentId,
        agent_node_config: &AgentNodeConfig,
        prompt: &str,
        conversational_context: Option<&str>,
        metadata_input: &str,
        node_config: &std::collections::HashMap<String, serde_json::Value>,
        agent: Arc<dyn AgentTrait>,
        node_id: &NodeId,
        node_name: &str,
        context: Arc<Mutex<WorkflowContext>>,
        guardrail_enforcer: Option<Arc<Enforcer>>,
        event_tx: Option<tokio::sync::mpsc::Sender<crate::stream::StreamEvent>>,
        stream_mode: crate::stream::StreamMode,
    ) -> GraphBitResult<serde_json::Value> {
        tracing::info!("Starting execute_agent_with_tools for agent: {_agent_id}");
        use crate::llm::{LlmMessage, LlmRequest, LlmTool};

        // ... (rest of tool calling logic, but with LlmRequest::with_messages handled correctly below)

        // Build the executions array for metadata
        let mut executions: Vec<serde_json::Value> = Vec::new();

        // Guardrail: encode prompt and context individually before sending to LLM
        let mut masked_input_for_meta = metadata_input.to_string();
        let prompt_for_llm = if let Some(ref enforcer) = guardrail_enforcer {
            tracing::debug!("Guardrail: encoding prompt and context before LLM call (tool path)");

            // 1. Encode context if present
            let (masked_context, signature_ctx, ctx_rules, ctx_count) =
                if let Some(ctx) = conversational_context {
                    let enc = enforcer.encode(
                        serde_json::Value::String(ctx.to_string()),
                        EncodeContext::Llm,
                    );
                    (
                        enc.payload.as_str().unwrap_or_default().to_string(),
                        enc.signature_injection_text,
                        enc.rule_names,
                        enc.rules_applied_count,
                    )
                } else {
                    (String::new(), String::new(), Vec::new(), 0)
                };

            // 2. Encode prompt
            let enc_prompt = enforcer.encode(
                serde_json::Value::String(prompt.to_string()),
                EncodeContext::Llm,
            );

            // 3. Encode metadata input specifically
            let enc_meta = enforcer.encode(
                serde_json::Value::String(metadata_input.to_string()),
                EncodeContext::Llm,
            );
            masked_input_for_meta = enc_meta.payload.as_str().unwrap_or_default().to_string();