Add TryCatch control node

New control node that executes a try-child and, on failure, runs a
catch-child as recovery. Supports configurable catch_on_halt behavior,
async children, and re-entry after RUNNING states.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: facontidavide

CMakeLists.txt

@@ -180,6 +180,7 @@ list(APPEND BT_SOURCE
     src/controls/sequence_node.cpp
     src/controls/sequence_with_memory_node.cpp
     src/controls/switch_node.cpp
+    src/controls/try_catch_node.cpp
     src/controls/while_do_else_node.cpp
 
     src/loggers/bt_cout_logger.cpp

include/behaviortree_cpp/behavior_tree.h

@@ -33,6 +33,7 @@
 #include "behaviortree_cpp/controls/sequence_node.h"
 #include "behaviortree_cpp/controls/sequence_with_memory_node.h"
 #include "behaviortree_cpp/controls/switch_node.h"
+#include "behaviortree_cpp/controls/try_catch_node.h"
 #include "behaviortree_cpp/controls/while_do_else_node.h"
 #include "behaviortree_cpp/decorators/delay_node.h"
 #include "behaviortree_cpp/decorators/force_failure_node.h"

include/behaviortree_cpp/controls/try_catch_node.h

@@ -0,0 +1,69 @@
+/* Copyright (C) 2018-2025 Davide Faconti, Eurecat -  All Rights Reserved
+*
+*   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
+*   to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+*   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#pragma once
+
+#include "behaviortree_cpp/control_node.h"
+
+namespace BT
+{
+/**
+ * @brief The TryCatch node executes children 1..N-1 as a Sequence ("try" block).
+ *
+ * If all children in the try-block succeed, this node returns SUCCESS.
+ *
+ * If any child in the try-block fails, the last child N is executed as a
+ * "catch" (cleanup) action, and this node returns FAILURE regardless of
+ * the catch child's result.
+ *
+ * - If a try-child returns RUNNING, this node returns RUNNING.
+ * - If a try-child returns SUCCESS, continue to the next try-child.
+ * - If a try-child returns FAILURE, enter catch mode and tick the last child.
+ * - If the catch child returns RUNNING, this node returns RUNNING.
+ * - When the catch child finishes (SUCCESS or FAILURE), this node returns FAILURE.
+ * - SKIPPED try-children are skipped over (not treated as failure).
+ *
+ * Port "catch_on_halt" (default false): if true, the catch child is also
+ * executed when the TryCatch node is halted while the try-block is RUNNING.
+ *
+ * Requires at least 2 children.
+ */
+class TryCatchNode : public ControlNode
+{
+public:
+  TryCatchNode(const std::string& name, const NodeConfig& config);
+
+  ~TryCatchNode() override = default;
+
+  TryCatchNode(const TryCatchNode&) = delete;
+  TryCatchNode& operator=(const TryCatchNode&) = delete;
+  TryCatchNode(TryCatchNode&&) = delete;
+  TryCatchNode& operator=(TryCatchNode&&) = delete;
+
+  static PortsList providedPorts()
+  {
+    return { InputPort<bool>("catch_on_halt", false,
+                             "If true, execute the catch child when "
+                             "the node is halted during the try-block") };
+  }
+
+  virtual void halt() override;
+
+private:
+  size_t current_child_idx_;
+  size_t skipped_count_;
+  bool in_catch_;
+
+  virtual BT::NodeStatus tick() override;
+};
+
+}  // namespace BT

src/bt_factory.cpp

@@ -131,6 +131,7 @@ BehaviorTreeFactory::BehaviorTreeFactory() : _p(new PImpl)
   registerNodeType<ReactiveFallback>("ReactiveFallback");
   registerNodeType<IfThenElseNode>("IfThenElse");
   registerNodeType<WhileDoElseNode>("WhileDoElse");
+  registerNodeType<TryCatchNode>("TryCatch");
 
   registerNodeType<InverterNode>("Inverter");
 

src/controls/try_catch_node.cpp

@@ -0,0 +1,137 @@
+/* Copyright (C) 2018-2025 Davide Faconti, Eurecat -  All Rights Reserved
+*
+*   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"),
+*   to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+*   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*   The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+*   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "behaviortree_cpp/controls/try_catch_node.h"
+
+namespace BT
+{
+TryCatchNode::TryCatchNode(const std::string& name, const NodeConfig& config)
+  : ControlNode::ControlNode(name, config)
+  , current_child_idx_(0)
+  , skipped_count_(0)
+  , in_catch_(false)
+{
+  setRegistrationID("TryCatch");
+}
+
+void TryCatchNode::halt()
+{
+  bool catch_on_halt = false;
+  getInput("catch_on_halt", catch_on_halt);
+
+  // If catch_on_halt is enabled and we were in the try-block (not already in catch),
+  // execute the catch child synchronously before halting.
+  if(catch_on_halt && !in_catch_ && isStatusActive(status()) &&
+     children_nodes_.size() >= 2)
+  {
+    // Halt all try-block children first
+    for(size_t i = 0; i < children_nodes_.size() - 1; i++)
+    {
+      haltChild(i);
+    }
+
+    // Tick the catch child. If it returns RUNNING, halt it too
+    // (best-effort cleanup during halt).
+    TreeNode* catch_child = children_nodes_.back();
+    const NodeStatus catch_status = catch_child->executeTick();
+    if(catch_status == NodeStatus::RUNNING)
+    {
+      haltChild(children_nodes_.size() - 1);
+    }
+  }
+
+  current_child_idx_ = 0;
+  skipped_count_ = 0;
+  in_catch_ = false;
+  ControlNode::halt();
+}
+
+NodeStatus TryCatchNode::tick()
+{
+  const size_t children_count = children_nodes_.size();
+
+  if(children_count < 2)
+  {
+    throw LogicError("[", name(), "]: TryCatch requires at least 2 children");
+  }
+
+  if(!isStatusActive(status()))
+  {
+    skipped_count_ = 0;
+    in_catch_ = false;
+  }
+
+  setStatus(NodeStatus::RUNNING);
+
+  const size_t try_count = children_count - 1;
+
+  // If we are in catch mode, tick the last child (cleanup)
+  if(in_catch_)
+  {
+    TreeNode* catch_child = children_nodes_.back();
+    const NodeStatus catch_status = catch_child->executeTick();
+
+    if(catch_status == NodeStatus::RUNNING)
+    {
+      return NodeStatus::RUNNING;
+    }
+
+    // Catch child finished (SUCCESS or FAILURE): return FAILURE
+    resetChildren();
+    current_child_idx_ = 0;
+    in_catch_ = false;
+    return NodeStatus::FAILURE;
+  }
+
+  // Try-block: execute children 0..N-2 as a Sequence
+  while(current_child_idx_ < try_count)
+  {
+    TreeNode* current_child_node = children_nodes_[current_child_idx_];
+    const NodeStatus child_status = current_child_node->executeTick();
+
+    switch(child_status)
+    {
+      case NodeStatus::RUNNING: {
+        return NodeStatus::RUNNING;
+      }
+      case NodeStatus::FAILURE: {
+        // Enter catch mode: halt try-block children, then tick catch child
+        resetChildren();
+        current_child_idx_ = 0;
+        in_catch_ = true;
+        return tick();  // re-enter to tick the catch child
+      }
+      case NodeStatus::SUCCESS: {
+        current_child_idx_++;
+      }
+      break;
+      case NodeStatus::SKIPPED: {
+        current_child_idx_++;
+        skipped_count_++;
+      }
+      break;
+      case NodeStatus::IDLE: {
+        throw LogicError("[", name(), "]: A child should not return IDLE");
+      }
+    }
+  }
+
+  // All try-children completed successfully (or were skipped)
+  const bool all_skipped = (skipped_count_ == try_count);
+  resetChildren();
+  current_child_idx_ = 0;
+  skipped_count_ = 0;
+
+  return all_skipped ? NodeStatus::SKIPPED : NodeStatus::SUCCESS;
+}
+
+}  // namespace BT

tests/CMakeLists.txt

@@ -46,6 +46,7 @@ set(BT_TESTS
   gtest_subtree.cpp
   gtest_switch.cpp
   gtest_tree.cpp
+  gtest_try_catch.cpp
   gtest_exception_tracking.cpp
   gtest_updates.cpp
   gtest_wakeup.cpp