diff --git a/src/api/callback.cc b/src/api/callback.cc
index 3d4f91a866ea39..8a0b71cd3626e2 100644
--- a/src/api/callback.cc
+++ b/src/api/callback.cc
@@ -266,6 +266,34 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
   return ret;
 }
 
+// Use this if you just want to safely invoke some JS callback and
+// would like to retain the currently active async_context, if any.
+// In case none is available, a fixed default context will be
+// installed otherwise.
+MaybeLocal<Value> MakeSyncCallback(Isolate* isolate,
+                                   Local<Object> recv,
+                                   Local<Function> callback,
+                                   int argc,
+                                   Local<Value> argv[]) {
+  Environment* env = Environment::GetCurrent(callback->CreationContext());
+  CHECK_NOT_NULL(env);
+  if (!env->can_call_into_js()) return Local<Value>();
+
+  Context::Scope context_scope(env->context());
+  if (env->async_callback_scope_depth()) {
+    // There's another MakeCallback() on the stack, piggy back on it.
+    // In particular, retain the current async_context.
+    return callback->Call(env->context(), recv, argc, argv);
+  }
+
+  // This is a toplevel invocation and the caller (intentionally)
+  // didn't provide any async_context to run in. Install a default context.
+  MaybeLocal<Value> ret =
+    InternalMakeCallback(env, env->process_object(), recv, callback, argc, argv,
+                         async_context{0, 0});
+  return ret;
+}
+
 // Legacy MakeCallback()s
 
 Local<Value> MakeCallback(Isolate* isolate,
diff --git a/src/node_internals.h b/src/node_internals.h
index f7a1e2d8d62c24..b75092d662dc97 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -200,6 +200,12 @@ v8::MaybeLocal<v8::Value> InternalMakeCallback(
     v8::Local<v8::Value> argv[],
     async_context asyncContext);
 
+v8::MaybeLocal<v8::Value> MakeSyncCallback(v8::Isolate* isolate,
+                                           v8::Local<v8::Object> recv,
+                                           v8::Local<v8::Function> callback,
+                                           int argc,
+                                           v8::Local<v8::Value> argv[]);
+
 class InternalCallbackScope {
  public:
   enum Flags {