Method handle_tool_calls_in_context

python/src/workflow/executor.rs:1797–2627

Handle tool calls in workflow context using an iterative ReAct loop. When an agent node returns `tool_calls_required`, this function: 1. Executes the requested tools via Python 2. Sends tool results back to the LLM WITH tool definitions 3. If the LLM requests more tools, repeats from step 1 4. Exits when the LLM returns a final answer (no tool calls) or max_iterations is reached This enables mul

(
        mut context: graphbit_core::types::WorkflowContext,
        workflow: &graphbit_core::workflow::Workflow,
        guardrail_enforcer: Option<&Enforcer>,
    )

    /// When `guardrail_enforcer` is `Some`, decodes tool-call parameters before execution only;
    /// after tool execution we do nothing (no encode of tool results).
    async fn handle_tool_calls_in_context(
        mut context: graphbit_core::types::WorkflowContext,
        workflow: &graphbit_core::workflow::Workflow,
        guardrail_enforcer: Option<&Enforcer>,
    ) -> Result<(graphbit_core::types::WorkflowContext, Vec<String>), graphbit_core::errors::GraphBitError> {
        use crate::workflow::node::execute_production_tool_calls;
        use graphbit_core::llm::{LlmMessage, LlmProvider, LlmRequest, LlmTool, LlmToolCall};

        // Check each node output for tool_calls_required responses
        let node_outputs = context.node_outputs.clone();
        let mut nodes_with_tool_calls: Vec<String> = Vec::new();

        for (node_id, output) in node_outputs {
            if let Ok(response_obj) = serde_json::from_value::<serde_json::Value>(output.clone()) {
                if let Some(response_type) = response_obj.get("type").and_then(|v| v.as_str()) {
                    if response_type == "tool_calls_required" {
                        // Extract initial tool calls and original prompt
                        if let (Some(initial_tool_calls), Some(original_prompt)) = (
                            response_obj.get("tool_calls"),
                            response_obj.get("original_prompt").and_then(|v| v.as_str()),
                        ) {
                            // Get the node from the workflow
                            let node = match workflow
                                .graph
                                .get_nodes()
                                .iter()
                                .find(|(id, _)| id.to_string() == node_id)
                                .map(|(_, node)| node.clone())
                            {
                                Some(n) => n,
                                None => continue,
                            };

                            // Only handle agent nodes
                            if !matches!(
                                node.node_type,
                                graphbit_core::graph::NodeType::Agent { .. }
                            ) {
                                continue;
                            }

                            nodes_with_tool_calls.push(node.id.to_string());

                            // Get node name for metadata storage
                            let node_name = workflow
                                .graph
                                .get_nodes()
                                .iter()
                                .find(|(id, _)| **id == node.id)
                                .map(|(_, n)| n.name.clone())
                                .unwrap_or_else(|| "unknown".to_string());

                            // Extract available tool names for this node
                            let node_tools = node
                                .config
                                .get("tools")
                                .and_then(|v| v.as_array())
                                .map(|arr| {