This is basically the middleware pattern except that each function is responsible for calling the next function in the chain. As a consequence, and contrary to the classic middleware pattern, the chain goes both ways, up to thhe api call, and down returning the result. The first expr is indeed special. It is in this context a level 0 function: it takes a context, does stuff, and returns the context. The other functions in the threading/-> expression are level 1 function: they return a level-0 function, in short they act like a factory. That returned function will be then threaded into the following level 1 function and so on. In the end the defined 'chatgpt' element is the whole chain. Call order is to be read from bottom to top.

Here's how level-1 functions are defined. 'ctx-fn' is just an indirection macro for 'fn' I haven't really used yet.

    (defn preserve-ctx [f & [at]]
      (let [mem (or at (atom {:ctx true}))]
        (ctx-fn
         :preserve-ctx [ctx]
         (if (->> ctx :it (cmd? :preserve-ctx))
           (do (case (:it ctx)
                 :preserve-ctx/get   @mem
                 :preserve-ctx/reset (doto {:ctx true}
                                       (->> (reset! mem))))
               (println (-> ctx :it) "done."))
           (-> ctx
               (when-not-> (-> :states :preserved)
                           (as-> $ (ctx-it (merge @mem $) (-> $ :it))))
               f
               (assoc-in [:states :preserved] true)
               (doto (->> (reset! mem))))))))

Edit: reading what I wrote, 'endpoint' is in fact a function returning function, except that since it's the "end" of the chain, it doesn't take a function to call next as argument.