                                                :context (:context options)
                                                :simulation-start simulation-start
                                                :sent-requests sent-requests))
-        responses (async/merge (map run-scenario-with-opts scenarios))
+        responses (async/merge (map run-scenario-with-opts (convert-from-legacy scenarios)))
         results (async/chan)]
     (go-loop []
              (if-let [result (<! responses)]

            (:fn request))))

(defn async-function-with-timeout [request timeout sent-requests user-id context]
  (let [start-promise (promise)
        end-promise (promise)
        response (async/chan)

    (println "Running scenario" (:name scenario)
             "with concurrency" concurrency)))

(defn legacy-request-fn->action [request]
  (let [f (if-let [url (:http request)]
            (partial http/async-http-request url)
            (:fn request))
        c (async/chan)]
    (fn [ctx]
      (f (fn [result & [new-ctx]]
           (if new-ctx
             (put! c [result new-ctx])
             (put! c [result ctx])))
         ctx)
      c)))

(defn convert-from-legacy [scenarios]
  (map (fn [scenario]
         (update scenario
                 :requests
                 (fn [requests]
                   (map #(assoc % :action (legacy-request-fn->action %)) requests))))
       scenarios))

(defn- run-scenario [options scenario]
  (print-scenario-info scenario)
  (let [responses (async/merge (map #(run-scenario-constantly options scenario %)
                                    (:users scenario)))
        results (async/chan)]
