Method execute_delegated_plan_tool

core/src/agent/tool_execution_runtime.rs:36–77

(
        &self,
        tool_name: &str,
        args: &Value,
        session_id: Option<&str>,
        event_tx: &Option<mpsc::Sender<AgentEvent>>,
    )

    }

    pub(super) async fn execute_delegated_plan_tool(
        &self,
        tool_name: &str,
        args: &Value,
        session_id: Option<&str>,
        event_tx: &Option<mpsc::Sender<AgentEvent>>,
    ) -> (String, i32, bool, Option<Value>) {
        let call_id = format!("plan-{}-{}", tool_name, uuid::Uuid::new_v4());
        if let Some(tx) = event_tx {
            tx.send(AgentEvent::ToolStart {
                id: call_id.clone(),
                name: tool_name.to_string(),
            })
            .await
            .ok();
        }

        let ctx = self.tool_context_for_plan(session_id);
        let normalized = NormalizedToolResult::from_execution(
            self.execute_tool_timed(tool_name, args, &ctx).await,
        );

        if let Some(tx) = event_tx {
            tx.send(AgentEvent::ToolEnd {
                id: call_id,
                name: tool_name.to_string(),
                output: normalized.output.clone(),
                exit_code: normalized.exit_code,
                metadata: normalized.metadata.clone(),
                error_kind: normalized.error_kind.clone(),
            })
            .await
            .ok();
        }

        (
            normalized.output,
            normalized.exit_code,
            normalized.is_error,
            normalized.metadata,
        )
    }

    /// Execute a tool, applying the configured timeout if set.
    ///