                                                :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)]

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

(defn- run-scenario [options scenario]
  (print-scenario-info scenario)

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

            (:fn request))))

(defn async-function-with-timeout [request timeout sent-requests user-id context]
  (swap! sent-requests inc)
  (let [start (now)
        response (asynchronize (:action request) (assoc context :user-id user-id))]
    (go
      (let [[[result end new-ctx] c] (alts! [response (async/timeout timeout)])]
        (if (= c response)
          [{:name (:name request)
            :id user-id
            :start start
            :end end
            :result result} new-ctx]
          [{:name (:name request)
            :id user-id
            :start start
            :end (now)
            :result false} context])))))

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