fast_curl 0.4.0 → 0.5.1

data/ext/fast_curl/fast_curl.c

@@ -20,18 +20,22 @@
 #include <strings.h>
 #include <time.h>
 
+void Init_fast_curl(void);
+
 #if defined(__GNUC__) || defined(__clang__)
 #define FAST_CURL_NORETURN __attribute__((noreturn))
 #else
 #define FAST_CURL_NORETURN
 #endif
 
-#define MAX_RESPONSE_SIZE          (100 * 1024 * 1024)
+#define MAX_RESPONSE_SIZE          ((size_t)100 * 1024 * 1024)
+#define MAX_RESPONSE_HEADER_SIZE   ((size_t)1024 * 1024)
 #define MAX_REDIRECTS              5
 #define MAX_TIMEOUT                300
 #define MAX_RETRIES                10
 #define MAX_REQUESTS               10000
 #define MAX_CONNECTIONS            100
+#define MAX_BUFFER                 10000
 #define MAX_RETRY_DELAY_MS         30000
 #define DEFAULT_RETRIES            1
 #define DEFAULT_RETRY_DELAY        100
@@ -72,6 +76,8 @@ typedef enum {
     KEY_EFFECTIVE_URL,
     KEY_ERROR,
     KEY_ATTEMPTS,
+    KEY_BUFFER,
+    KEY_ACCEPT,
     KEY_LAST
 } key_id_t;
 
@@ -101,6 +107,8 @@ static const char *const KEY_NAMES[KEY_LAST] = {
     "effective_url",
     "error",
     "attempts",
+    "buffer",
+    "accept",
 };
 
 typedef enum {
@@ -253,29 +261,63 @@ typedef struct {
 
 typedef struct {
     header_entry_t *entries;
-    int count;
-    int cap;
+    size_t count;
+    size_t cap;
+    size_t total_bytes;
 } header_list_t;
 
 static inline void header_list_init(header_list_t *h) {
     h->entries = NULL;
     h->count = 0;
     h->cap = 0;
+    h->total_bytes = 0;
 }
 
 static void header_list_free(header_list_t *h) {
-    for (int i = 0; i < h->count; i++)
+    for (size_t i = 0; i < h->count; i++)
         free(h->entries[i].str);
     free(h->entries);
     h->entries = NULL;
     h->count = 0;
     h->cap = 0;
+    h->total_bytes = 0;
 }
 
 static void header_list_reset(header_list_t *h) {
-    for (int i = 0; i < h->count; i++)
+    for (size_t i = 0; i < h->count; i++)
         free(h->entries[i].str);
     h->count = 0;
+    h->total_bytes = 0;
+}
+
+static int header_list_add_bytes(header_list_t *h, size_t total) {
+    if (h->total_bytes > MAX_RESPONSE_HEADER_SIZE ||
+        total > MAX_RESPONSE_HEADER_SIZE - h->total_bytes)
+        return 0;
+
+    h->total_bytes += total;
+    return 1;
+}
+
+static int header_list_reserve(header_list_t *h) {
+    if (h->count < h->cap)
+        return 1;
+
+    size_t new_cap = h->cap ? h->cap : INITIAL_HEADER_CAP;
+    if (h->cap && h->cap > SIZE_MAX / 2)
+        return 0;
+    if (h->cap)
+        new_cap = h->cap * 2;
+    if (new_cap > SIZE_MAX / sizeof(*h->entries))
+        return 0;
+
+    header_entry_t *entries = realloc(h->entries, sizeof(*h->entries) * new_cap);
+    if (!entries)
+        return 0;
+
+    h->entries = entries;
+    h->cap = new_cap;
+    return 1;
 }
 
 static size_t header_callback(char *ptr, size_t size, size_t nmemb, void *userdata) {
@@ -289,22 +331,18 @@ static size_t header_callback(char *ptr, size_t size, size_t nmemb, void *userda
     while (stripped > 0 && (ptr[stripped - 1] == '\r' || ptr[stripped - 1] == '\n'))
         stripped--;
 
-    if (stripped >= 5 && memcmp(ptr, "HTTP/", 5) == 0) {
+    int status_line = stripped >= 5 && memcmp(ptr, "HTTP/", 5) == 0;
+    if (status_line)
         header_list_reset(h);
-        return total;
-    }
 
-    if (stripped == 0)
+    if (!header_list_add_bytes(h, total))
+        return 0;
+
+    if (status_line || stripped == 0)
         return total;
 
-    if (h->count >= h->cap) {
-        int new_cap = (h->cap == 0) ? INITIAL_HEADER_CAP : h->cap * 2;
-        header_entry_t *ne = realloc(h->entries, sizeof(header_entry_t) * new_cap);
-        if (!ne)
-            return 0;
-        h->entries = ne;
-        h->cap = new_cap;
-    }
+    if (!header_list_reserve(h))
+        return 0;
 
     char *entry = malloc(stripped + 1);
     if (!entry)
@@ -320,7 +358,7 @@ static size_t header_callback(char *ptr, size_t size, size_t nmemb, void *userda
 
 typedef struct {
     CURL *easy;
-    int index;
+    long index;
     buffer_t body;
     header_list_t headers;
     struct curl_slist *req_headers;
@@ -341,7 +379,7 @@ static VALUE fast_validation_error = Qnil;
         (ctx)->setup_error_fatal = (fatal); \
     } while (0)
 
-static inline void request_ctx_init(request_ctx_t *ctx, int index) {
+static inline void request_ctx_init(request_ctx_t *ctx, long index) {
     ctx->easy = NULL;
     ctx->index = index;
     buffer_init(&ctx->body);
@@ -410,7 +448,7 @@ typedef struct {
     int still_running;
     long timeout_ms;
     int max_connections;
-    volatile int cancelled;
+    int cancelled;
 
     int active_count;
     int pending_pos;
@@ -418,12 +456,21 @@ typedef struct {
     int *pending_indices;
 } multi_session_t;
 
+static int session_cancelled(const multi_session_t *session) {
+    return __atomic_load_n(&session->cancelled, __ATOMIC_ACQUIRE);
+}
+
+static void cancel_session(multi_session_t *session) {
+    __atomic_store_n(&session->cancelled, 1, __ATOMIC_RELEASE);
+}
+
 typedef struct {
     int max_retries;
     int retries_explicit;
     long retry_delay_ms;
     int *retry_http_codes;
     int retry_http_count;
+    VALUE retry_code_values;
     int retry_non_idempotent;
 } retry_config_t;
 
@@ -566,7 +613,7 @@ static VALUE build_response(request_ctx_t *ctx) {
     curl_easy_getinfo(ctx->easy, CURLINFO_RESPONSE_CODE, &status);
 
     VALUE headers_hash = new_headers_hash();
-    for (int i = 0; i < ctx->headers.count; i++) {
+    for (size_t i = 0; i < ctx->headers.count; i++) {
         const char *hdr = ctx->headers.entries[i].str;
         size_t hdr_len = ctx->headers.entries[i].len;
         const char *colon = memchr(hdr, ':', hdr_len);
@@ -593,7 +640,7 @@ static VALUE build_response(request_ctx_t *ctx) {
     }
 
     VALUE body_str =
-        ctx->body.data ? rb_str_new(ctx->body.data, ctx->body.len) : rb_str_new_cstr("");
+        ctx->body.data ? rb_str_new(ctx->body.data, (long)ctx->body.len) : rb_str_new_cstr("");
 
     VALUE result = rb_hash_new();
     rb_hash_aset(result, SYM(KEY_STATUS), LONG2NUM(status));
@@ -638,7 +685,7 @@ static int is_valid_url(const char *url) {
         return 0;
     if (strncmp(url, "https://", 8) == 0)
         return 1;
-    if (len >= 7 && strncmp(url, "http://", 7) == 0)
+    if (strncmp(url, "http://", 7) == 0)
         return 1;
     return 0;
 }
@@ -881,7 +928,7 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, const request_op
         SET_SETUP_ERROR(ctx, "Missing :url", 0);
         return 0;
     }
-    if (!RB_TYPE_P(url, T_STRING) || memchr(RSTRING_PTR(url), '\0', RSTRING_LEN(url))) {
+    if (!RB_TYPE_P(url, T_STRING) || memchr(RSTRING_PTR(url), '\0', (size_t)RSTRING_LEN(url))) {
         SET_SETUP_ERROR(ctx, "Invalid URL", 1);
         return 0;
     }
@@ -929,6 +976,67 @@ static int setup_easy_handle(request_ctx_t *ctx, VALUE request, const request_op
     return 1;
 }
 
+typedef struct {
+    request_ctx_t request;
+    VALUE value;
+    const request_options_t *options;
+    long index;
+    int fatal;
+    char message[128];
+} request_probe_t;
+
+static VALUE request_probe_body(VALUE arg) {
+    request_probe_t *probe = (request_probe_t *)(uintptr_t)arg;
+    request_ctx_init(&probe->request, probe->index);
+    if (!request_ctx_prepare_easy(&probe->request))
+        return Qnil;
+
+    setup_easy_handle(&probe->request, probe->value, probe->options);
+    probe->fatal = probe->request.setup_error_fatal;
+    if (probe->fatal && probe->request.setup_error)
+        snprintf(probe->message, sizeof(probe->message), "%s (request %ld)",
+                 probe->request.setup_error, probe->index);
+    return Qnil;
+}
+
+static VALUE request_probe_ensure(VALUE arg) {
+    request_probe_t *probe = (request_probe_t *)(uintptr_t)arg;
+    request_ctx_free(&probe->request);
+    return Qnil;
+}
+
+static int validate_request_probe(VALUE request, long index, const request_options_t *options,
+                                  char message[128]) {
+    request_probe_t probe;
+    memset(&probe, 0, sizeof(probe));
+    probe.value = request;
+    probe.options = options;
+    probe.index = index;
+    rb_ensure(request_probe_body, (VALUE)(uintptr_t)&probe, request_probe_ensure,
+              (VALUE)(uintptr_t)&probe);
+    if (probe.fatal)
+        memcpy(message, probe.message, sizeof(probe.message));
+    RB_GC_GUARD(request);
+    return probe.fatal;
+}
+
+static void validate_execute_requests(VALUE requests, int count, int target, VALUE options,
+                                      const request_options_t *opts) {
+    if (target > 0 && !NIL_P(options)) {
+        VALUE accept = hash_aref_key(options, KEY_ACCEPT);
+        if (!NIL_P(accept) && !rb_respond_to(accept, rb_intern("call")))
+            rb_raise(rb_eArgError, "accept must respond to #call");
+    }
+
+    for (int i = 0; i < count; i++) {
+        char message[128];
+        if (validate_request_probe(rb_ary_entry(requests, i), i, opts, message)) {
+            VALUE klass = NIL_P(fast_validation_error) ? rb_eArgError : fast_validation_error;
+            rb_raise(klass, "%s", message);
+        }
+    }
+}
+
 /* Poll until something actually completes, or the slice budget expires.
    Previously this returned after every single 50ms poll, which under a fiber
    scheduler meant a fresh OS thread twenty times a second. Cancellation still
@@ -938,7 +1046,7 @@ static void *poll_without_gvl(void *arg) {
     long long started = fast_now_ms();
     int before = s->still_running;
 
-    while (!s->cancelled) {
+    while (!session_cancelled(s)) {
         int numfds = 0;
         curl_multi_poll(s->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
         curl_multi_perform(s->multi, &s->still_running);
@@ -953,7 +1061,7 @@ static void *poll_without_gvl(void *arg) {
 
 static void unblock_perform(void *arg) {
     multi_session_t *s = (multi_session_t *)arg;
-    s->cancelled = 1;
+    cancel_session(s);
 #ifdef HAVE_CURL_MULTI_WAKEUP
     curl_multi_wakeup(s->multi);
 #endif
@@ -961,30 +1069,52 @@ static void unblock_perform(void *arg) {
 
 typedef struct {
     VALUE results;
+    VALUE accept;
     int completed;
     int target;
     int stream;
 } completion_ctx_t;
 
-static VALUE build_result_pair(int index, VALUE response) {
-    return rb_ary_new_from_args(2, INT2NUM(index), response);
+static VALUE build_result_pair(long index, VALUE response) {
+    return rb_ary_new_from_args(2, LONG2NUM(index), response);
 }
 
-static int record_immediate_error(completion_ctx_t *cctx, int index, const char *message,
-                                  int attempts) {
-    if (cctx->stream || cctx->target > 0) {
-        VALUE pair =
-            build_result_pair(index, build_error_response(message, ERR_INVALID_REQUEST, attempts));
+static int response_accepted(completion_ctx_t *cctx, VALUE response) {
+    if (cctx->target <= 0 || NIL_P(cctx->accept))
+        return 1;
 
-        if (cctx->stream)
-            rb_yield(pair);
-        else
-            rb_ary_push(cctx->results, pair);
+    return RTEST(rb_funcall(cctx->accept, rb_intern("call"), 1, response));
+}
 
+static int record_response(completion_ctx_t *cctx, long index, VALUE response) {
+    VALUE pair = build_result_pair(index, response);
+
+    if (cctx->stream) {
+        rb_yield(pair);
         cctx->completed++;
-        if (cctx->target > 0 && cctx->completed >= cctx->target)
-            return 1;
+        return 0;
+    }
+
+    if (cctx->target > 0) {
+        if (!response_accepted(cctx, response))
+            return 0;
+
+        rb_ary_push(cctx->results, pair);
+        cctx->completed++;
+        return cctx->completed >= cctx->target;
     }
+
+    rb_ary_store(cctx->results, index, pair);
+    cctx->completed++;
+    return 0;
+}
+
+static int record_immediate_error(completion_ctx_t *cctx, long index, const char *message,
+                                  int attempts) {
+    if (cctx->stream || cctx->target > 0)
+        return record_response(cctx, index,
+                               build_error_response(message, ERR_INVALID_REQUEST, attempts));
+
     return 0;
 }
 
@@ -1019,17 +1149,11 @@ static int process_completed(multi_session_t *session, completion_ctx_t *cctx) {
                     ? build_response(ctx)
                     : build_error_response_with_code(curl_easy_strerror(msg->data.result),
                                                      (int)msg->data.result, ctx->attempts);
-            VALUE pair = build_result_pair(ctx->index, response);
-
-            if (cctx->stream)
-                rb_yield(pair);
-            else
-                rb_ary_push(cctx->results, pair);
+            if (record_response(cctx, ctx->index, response))
+                return 1;
+        } else {
+            cctx->completed++;
         }
-
-        cctx->completed++;
-        if (cctx->target > 0 && cctx->completed >= cctx->target)
-            return 1;
     }
 
     return 0;
@@ -1123,7 +1247,8 @@ static void run_multi_loop(multi_session_t *session, completion_ctx_t *cctx, VAL
     if (process_completed(session, cctx))
         return;
 
-    while (!session->cancelled && (session->active_count > 0 || pending_remaining(session))) {
+    while (!session_cancelled(session) &&
+           (session->active_count > 0 || pending_remaining(session))) {
         if (opts->deadline_ms > 0 && fast_now_ms() >= opts->deadline_ms)
             break;
 
@@ -1208,6 +1333,7 @@ static void retry_config_init(retry_config_t *retry_cfg) {
     retry_cfg->retry_delay_ms = DEFAULT_RETRY_DELAY;
     retry_cfg->retry_http_codes = NULL;
     retry_cfg->retry_http_count = 0;
+    retry_cfg->retry_code_values = Qnil;
     retry_cfg->retry_non_idempotent = 0;
 }
 
@@ -1266,22 +1392,33 @@ static void parse_retry_codes(VALUE options, retry_config_t *retry_cfg) {
         rb_raise(rb_eArgError, "retry_codes is too large");
 
     len = (int)len_long;
+    VALUE normalized = rb_ary_new_capa(len);
     for (int i = 0; i < len; i++) {
         int code = NUM2INT(rb_ary_entry(codes, i));
         if (code < 100 || code > 599)
             rb_raise(rb_eArgError, "retry_codes must contain valid HTTP status codes");
+        rb_ary_push(normalized, INT2NUM(code));
     }
 
-    if (len == 0)
+    retry_cfg->retry_code_values = normalized;
+    retry_cfg->retry_http_count = len;
+    RB_GC_GUARD(codes);
+}
+
+static void materialize_retry_codes(retry_config_t *retry_cfg) {
+    if (retry_cfg->retry_http_count == 0)
         return;
 
-    retry_cfg->retry_http_codes = malloc(sizeof(int) * (size_t)len);
+    size_t count = (size_t)retry_cfg->retry_http_count;
+    if (count > SIZE_MAX / sizeof(*retry_cfg->retry_http_codes))
+        rb_raise(rb_eArgError, "retry_codes is too large");
+
+    retry_cfg->retry_http_codes = malloc(sizeof(*retry_cfg->retry_http_codes) * count);
     if (!retry_cfg->retry_http_codes)
         rb_raise(rb_eNoMemError, "failed to allocate retry codes");
 
-    retry_cfg->retry_http_count = len;
-    for (int i = 0; i < len; i++)
-        retry_cfg->retry_http_codes[i] = NUM2INT(rb_ary_entry(codes, i));
+    for (int i = 0; i < retry_cfg->retry_http_count; i++)
+        retry_cfg->retry_http_codes[i] = NUM2INT(rb_ary_entry(retry_cfg->retry_code_values, i));
 }
 
 static void parse_options(VALUE options, request_options_t *opts, int *max_conn,
@@ -1326,7 +1463,17 @@ static void parse_options(VALUE options, request_options_t *opts, int *max_conn,
     retry_cfg->retry_delay_ms =
         parse_long_option(options, KEY_RETRY_DELAY, "retry_delay", 0, MAX_RETRY_DELAY_MS,
                           retry_cfg->retry_delay_ms, NULL);
-    parse_retry_codes(options, retry_cfg);
+}
+
+static void configure_retry_mode(retry_config_t *retry_cfg, int target, int stream) {
+    if (!stream && target <= 0)
+        return;
+
+    if (retry_cfg->retries_explicit && retry_cfg->max_retries > 0 && stream)
+        rb_warn("FastCurl: retries are not supported in stream_execute, ignoring retries option");
+    if (retry_cfg->retries_explicit && retry_cfg->max_retries > 0 && target > 0)
+        rb_warn("FastCurl: retries are not supported in first_execute, ignoring retries option");
+    retry_cfg->max_retries = 0;
 }
 
 static void multi_session_init(multi_session_t *session, CURLM *multi, int count, int max_conn,
@@ -1389,6 +1536,27 @@ static FAST_CURL_NORETURN void cleanup_and_raise(cleanup_ctx_t *cleanup, VALUE e
     rb_raise(exception, "%s", message);
 }
 
+static void prepare_execute_session(multi_session_t *session, int **invalid, cleanup_ctx_t *cleanup,
+                                    retry_config_t *retry_cfg, int count, int max_conn,
+                                    long timeout_sec) {
+    multi_session_init(session, curl_multi_init(), count, max_conn, timeout_sec);
+    cleanup->session = session;
+    cleanup->invalid = NULL;
+    cleanup->retry_cfg = retry_cfg;
+    if (!session->multi)
+        cleanup_and_raise(cleanup, rb_eNoMemError, "failed to initialize curl multi handle");
+
+    multi_session_configure(session->multi, max_conn);
+    session->requests = calloc((size_t)count, sizeof(*session->requests));
+    if (!session->requests)
+        cleanup_and_raise(cleanup, rb_eNoMemError, "failed to allocate request contexts");
+
+    *invalid = calloc((size_t)count, sizeof(**invalid));
+    cleanup->invalid = *invalid;
+    if (!*invalid)
+        cleanup_and_raise(cleanup, rb_eNoMemError, "failed to allocate tracking array");
+}
+
 typedef struct {
     VALUE requests;
     VALUE options;
@@ -1400,126 +1568,623 @@ typedef struct {
     request_options_t *opts;
 } execute_args_t;
 
+static void completion_context_init(completion_ctx_t *cctx, const execute_args_t *ea, int count) {
+    cctx->results =
+        ea->stream ? Qnil : (ea->target > 0 ? rb_ary_new2(ea->target) : rb_ary_new2(count));
+    cctx->accept =
+        ea->target > 0 && !NIL_P(ea->options) ? hash_aref_key(ea->options, KEY_ACCEPT) : Qnil;
+    cctx->completed = 0;
+    cctx->target = ea->target;
+    cctx->stream = ea->stream;
+
+    if (!NIL_P(cctx->accept) && !rb_respond_to(cctx->accept, rb_intern("call")))
+        rb_raise(rb_eArgError, "accept must respond to #call");
+
+    if (!ea->stream && ea->target <= 0) {
+        for (int i = 0; i < count; i++)
+            rb_ary_store(cctx->results, i, Qnil);
+    }
+}
+
+static int retry_one_attempt(execute_args_t *ea, completion_ctx_t *cctx, int *deadline_hit,
+                             int attempt) {
+    multi_session_t *session = ea->session;
+    int count = session->count;
+    request_options_t *opts = ea->opts;
+    retry_config_t *retry_cfg = ea->retry_cfg;
+
+    if (opts->deadline_ms > 0 && fast_now_ms() >= opts->deadline_ms) {
+        *deadline_hit = 1;
+        return 0;
+    }
+
+    int *retry_indices = ALLOCA_N(int, count);
+    int retry_count = 0;
+    for (int i = 0; i < count; i++) {
+        if (!ea->invalid[i] && session->requests[i].done &&
+            should_retry(&session->requests[i], retry_cfg))
+            retry_indices[retry_count++] = i;
+    }
+
+    if (retry_count == 0)
+        return 0;
+
+    long backoff = retry_backoff_ms(retry_cfg, attempt);
+    if (opts->deadline_ms > 0) {
+        long long left = opts->deadline_ms - fast_now_ms();
+        if (left <= 0) {
+            *deadline_hit = 1;
+            return 0;
+        }
+        if (backoff > (long)left)
+            backoff = (long)left;
+    }
+    retry_delay_sleep(backoff);
+
+    int runnable_count = 0;
+    for (int r = 0; r < retry_count; r++) {
+        int idx = retry_indices[r];
+        request_ctx_t *request = &session->requests[idx];
+        if (!request_ctx_reset_for_retry(request)) {
+            ea->invalid[idx] = 1;
+            request->done = 1;
+            request->setup_error = "Failed to allocate a curl handle for the retry";
+            continue;
+        }
+
+        retry_indices[runnable_count++] = idx;
+    }
+
+    if (runnable_count > 0) {
+        cctx->completed = 0;
+        run_multi_loop(session, cctx, ea->requests, ea->invalid, opts, retry_indices,
+                       runnable_count);
+    }
+    return 1;
+}
+
+static int retry_completed_requests(execute_args_t *ea, completion_ctx_t *cctx) {
+    int deadline_hit = 0;
+    for (int attempt = 0; attempt < ea->retry_cfg->max_retries; attempt++) {
+        if (!retry_one_attempt(ea, cctx, &deadline_hit, attempt))
+            break;
+    }
+    return deadline_hit;
+}
+
+static void store_execution_results(execute_args_t *ea, completion_ctx_t *cctx, int deadline_hit) {
+    multi_session_t *session = ea->session;
+    request_options_t *opts = ea->opts;
+    for (int i = 0; i < session->count; i++) {
+        request_ctx_t *request = &session->requests[i];
+        VALUE response;
+
+        if (ea->invalid[i]) {
+            response = build_error_response(request->setup_error ? request->setup_error
+                                                                 : "Invalid request configuration",
+                                            ERR_INVALID_REQUEST, request->attempts);
+        } else if (!request->done) {
+            response = deadline_hit || (opts->deadline_ms > 0 && fast_now_ms() >= opts->deadline_ms)
+                           ? build_error_response("Total timeout exceeded", ERR_DEADLINE,
+                                                  request->attempts)
+                           : build_error_response("Request was not completed", ERR_NOT_COMPLETED,
+                                                  request->attempts);
+        } else if (request->curl_result == CURLE_OK) {
+            response = build_response(request);
+        } else {
+            response = build_error_response_with_code(curl_easy_strerror(request->curl_result),
+                                                      (int)request->curl_result, request->attempts);
+        }
+
+        rb_ary_store(cctx->results, i, build_result_pair(i, response));
+    }
+}
+
 static VALUE internal_execute_body(VALUE arg) {
     execute_args_t *ea = (execute_args_t *)arg;
-    VALUE requests = ea->requests;
     multi_session_t *session = ea->session;
-    int *invalid = ea->invalid;
     retry_config_t *retry_cfg = ea->retry_cfg;
     request_options_t *opts = ea->opts;
-    int deadline_hit = 0;
     int count = session->count;
-    int target = ea->target;
-    int stream = ea->stream;
 
     for (int i = 0; i < count; i++)
         request_ctx_init(&session->requests[i], i);
 
     completion_ctx_t cctx;
-    cctx.results = stream ? Qnil : ((target > 0) ? rb_ary_new2(target) : rb_ary_new2(count));
-    cctx.completed = 0;
-    cctx.target = target;
-    cctx.stream = stream;
-
-    if (!stream && target <= 0) {
-        for (int i = 0; i < count; i++)
-            rb_ary_store(cctx.results, i, Qnil);
-    }
+    completion_context_init(&cctx, ea, count);
 
     if (opts->total_timeout_ms > 0)
         opts->deadline_ms = fast_now_ms() + opts->total_timeout_ms;
 
-    run_multi_loop(session, &cctx, requests, invalid, opts, NULL, count);
+    run_multi_loop(session, &cctx, ea->requests, ea->invalid, opts, NULL, count);
 
-    if (!stream && target <= 0 && retry_cfg->max_retries > 0) {
-        for (int attempt = 0; attempt < retry_cfg->max_retries; attempt++) {
-            if (opts->deadline_ms > 0 && fast_now_ms() >= opts->deadline_ms) {
-                deadline_hit = 1;
-                break;
-            }
+    int deadline_hit = 0;
+    if (!ea->stream && ea->target <= 0 && retry_cfg->max_retries > 0)
+        deadline_hit = retry_completed_requests(ea, &cctx);
 
-            int *retry_indices = malloc(sizeof(int) * (size_t)count);
-            if (!retry_indices)
-                rb_raise(rb_eNoMemError, "failed to allocate retry index array");
+    if (!ea->stream && ea->target <= 0)
+        store_execution_results(ea, &cctx, deadline_hit);
 
-            int retry_count = 0;
-            for (int i = 0; i < count; i++) {
-                if (invalid[i] || !session->requests[i].done)
-                    continue;
-                if (should_retry(&session->requests[i], retry_cfg))
-                    retry_indices[retry_count++] = i;
-            }
+    return ea->stream ? Qnil : cctx.results;
+}
 
-            if (retry_count == 0) {
-                free(retry_indices);
-                break;
-            }
+typedef enum {
+    LAZY_SLOT_FREE,
+    LAZY_SLOT_PENDING,
+    LAZY_SLOT_ACTIVE,
+    LAZY_SLOT_RETRY_WAIT
+} lazy_slot_state_t;
 
-            long backoff = retry_backoff_ms(retry_cfg, attempt);
-            if (opts->deadline_ms > 0) {
-                long long left = opts->deadline_ms - fast_now_ms();
-                if (left <= 0) {
-                    deadline_hit = 1;
-                    free(retry_indices);
-                    break;
-                }
-                if (backoff > (long)left)
-                    backoff = (long)left;
-            }
-            retry_delay_sleep(backoff);
+typedef struct {
+    multi_session_t session;
+    request_options_t opts;
+    retry_config_t retry_cfg;
+    completion_ctx_t cctx;
+    VALUE source;
+    VALUE anchors;
+    int *states;
+    int *free_slots;
+    int free_count;
+    int *pending_slots;
+    int pending_head;
+    int pending_tail;
+    int pending_count;
+    long long *retry_at_ms;
+    int capacity;
+    int buffer_size;
+    int occupied_count;
+    long next_index;
+    int deadline_hit;
+    int stop;
+} lazy_execute_ctx_t;
+
+static int lazy_pending_push(lazy_execute_ctx_t *ctx, int slot) {
+    if (ctx->pending_count >= ctx->capacity)
+        return 0;
 
-            int runnable_count = 0;
-            for (int r = 0; r < retry_count; r++) {
-                int idx = retry_indices[r];
-                request_ctx_t *rc = &session->requests[idx];
+    ctx->pending_slots[ctx->pending_tail] = slot;
+    ctx->pending_tail = (ctx->pending_tail + 1) % ctx->capacity;
+    ctx->pending_count++;
+    return 1;
+}
 
-                if (!request_ctx_reset_for_retry(rc)) {
-                    invalid[idx] = 1;
-                    rc->done = 1;
-                    rc->setup_error = "Failed to allocate a curl handle for the retry";
-                    continue;
-                }
+static int lazy_pending_pop(lazy_execute_ctx_t *ctx) {
+    if (ctx->pending_count == 0)
+        return -1;
 
-                retry_indices[runnable_count++] = idx;
-            }
+    int slot = ctx->pending_slots[ctx->pending_head];
+    ctx->pending_head = (ctx->pending_head + 1) % ctx->capacity;
+    ctx->pending_count--;
+    return slot;
+}
 
-            if (runnable_count > 0) {
-                cctx.completed = 0;
-                run_multi_loop(session, &cctx, requests, invalid, opts, retry_indices,
-                               runnable_count);
-            }
+static void lazy_release_slot(lazy_execute_ctx_t *ctx, int slot) {
+    request_ctx_free(&ctx->session.requests[slot]);
+    rb_ary_store(ctx->anchors, slot, Qnil);
+    ctx->states[slot] = LAZY_SLOT_FREE;
+    ctx->retry_at_ms[slot] = 0;
+    ctx->free_slots[ctx->free_count++] = slot;
+    if (ctx->occupied_count > 0)
+        ctx->occupied_count--;
+}
 
-            free(retry_indices);
+static FAST_CURL_NORETURN void lazy_raise_setup_error(request_ctx_t *request) {
+    VALUE klass = NIL_P(fast_validation_error) ? rb_eArgError : fast_validation_error;
+    rb_raise(klass, "%s (request %ld)",
+             request->setup_error ? request->setup_error : "Invalid request configuration",
+             request->index);
+}
+
+static int lazy_finalize_error(lazy_execute_ctx_t *ctx, int slot, const char *message) {
+    request_ctx_t *request = &ctx->session.requests[slot];
+    VALUE response = build_error_response(message, ERR_INVALID_REQUEST, request->attempts);
+    int stop = record_response(&ctx->cctx, request->index, response);
+    lazy_release_slot(ctx, slot);
+    return stop;
+}
+
+static int lazy_activate_pending(lazy_execute_ctx_t *ctx) {
+    while (ctx->session.active_count < ctx->session.max_connections && ctx->pending_count > 0) {
+        int slot = lazy_pending_pop(ctx);
+        request_ctx_t *request = &ctx->session.requests[slot];
+        VALUE request_value = rb_ary_entry(ctx->anchors, slot);
+
+        if (!request_ctx_prepare_easy(request)) {
+            if (lazy_finalize_error(ctx, slot, "Failed to allocate a curl handle"))
+                return 1;
+            continue;
         }
+
+        if (!setup_easy_handle(request, request_value, &ctx->opts)) {
+            if (request->setup_error_fatal)
+                lazy_raise_setup_error(request);
+            if (lazy_finalize_error(ctx, slot,
+                                    request->setup_error ? request->setup_error
+                                                         : "Invalid request configuration"))
+                return 1;
+            continue;
+        }
+
+        if (curl_multi_add_handle(ctx->session.multi, request->easy) != CURLM_OK) {
+            if (lazy_finalize_error(ctx, slot, "Failed to schedule the request"))
+                return 1;
+            continue;
+        }
+
+        request->attempts++;
+        request->active = 1;
+        request->done = 0;
+        ctx->states[slot] = LAZY_SLOT_ACTIVE;
+        ctx->session.active_count++;
     }
 
-    if (!stream && target <= 0) {
-        for (int i = 0; i < count; i++) {
-            request_ctx_t *rc = &session->requests[i];
-            VALUE response;
-
-            if (invalid[i]) {
-                response = build_error_response(rc->setup_error ? rc->setup_error
-                                                                : "Invalid request configuration",
-                                                ERR_INVALID_REQUEST, rc->attempts);
-            } else if (!rc->done) {
-                response =
-                    deadline_hit || (opts->deadline_ms > 0 && fast_now_ms() >= opts->deadline_ms)
-                        ? build_error_response("Total timeout exceeded", ERR_DEADLINE, rc->attempts)
-                        : build_error_response("Request was not completed", ERR_NOT_COMPLETED,
-                                               rc->attempts);
-            } else if (rc->curl_result == CURLE_OK) {
-                response = build_response(rc);
-            } else {
-                response = build_error_response_with_code(curl_easy_strerror(rc->curl_result),
-                                                          (int)rc->curl_result, rc->attempts);
-            }
+    return 0;
+}
+
+static int lazy_activate_retries(lazy_execute_ctx_t *ctx) {
+    long long now = fast_now_ms();
+
+    for (int slot = 0;
+         slot < ctx->capacity && ctx->session.active_count < ctx->session.max_connections; slot++) {
+        if (ctx->states[slot] != LAZY_SLOT_RETRY_WAIT || ctx->retry_at_ms[slot] > now)
+            continue;
+
+        request_ctx_t *request = &ctx->session.requests[slot];
+        VALUE request_value = rb_ary_entry(ctx->anchors, slot);
+
+        if (!request_ctx_reset_for_retry(request)) {
+            if (lazy_finalize_error(ctx, slot, "Failed to allocate a curl handle for the retry"))
+                return 1;
+            continue;
+        }
+
+        if (!setup_easy_handle(request, request_value, &ctx->opts)) {
+            if (request->setup_error_fatal)
+                lazy_raise_setup_error(request);
+            if (lazy_finalize_error(ctx, slot,
+                                    request->setup_error ? request->setup_error
+                                                         : "Invalid request configuration"))
+                return 1;
+            continue;
+        }
+
+        if (curl_multi_add_handle(ctx->session.multi, request->easy) != CURLM_OK) {
+            if (lazy_finalize_error(ctx, slot, "Failed to schedule the retry"))
+                return 1;
+            continue;
+        }
+
+        request->attempts++;
+        request->active = 1;
+        request->done = 0;
+        ctx->states[slot] = LAZY_SLOT_ACTIVE;
+        ctx->retry_at_ms[slot] = 0;
+        ctx->session.active_count++;
+    }
+
+    return 0;
+}
+
+static long long lazy_next_retry_at(const lazy_execute_ctx_t *ctx) {
+    long long next = 0;
+    for (int slot = 0; slot < ctx->capacity; slot++) {
+        if (ctx->states[slot] != LAZY_SLOT_RETRY_WAIT)
+            continue;
+        if (next == 0 || ctx->retry_at_ms[slot] < next)
+            next = ctx->retry_at_ms[slot];
+    }
+    return next;
+}
+
+static int lazy_process_completed(lazy_execute_ctx_t *ctx) {
+    CURLMsg *msg;
+    int msgs_left;
+
+    while ((msg = curl_multi_info_read(ctx->session.multi, &msgs_left))) {
+        if (msg->msg != CURLMSG_DONE)
+            continue;
+
+        request_ctx_t *request = NULL;
+        curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, (char **)&request);
+        if (!request || request->done)
+            continue;
+
+        int slot = (int)(request - ctx->session.requests);
+        if (slot < 0 || slot >= ctx->capacity)
+            continue;
+
+        if (request->active) {
+            curl_multi_remove_handle(ctx->session.multi, request->easy);
+            request->active = 0;
+            if (ctx->session.active_count > 0)
+                ctx->session.active_count--;
+        }
+
+        request->done = 1;
+        request->curl_result = msg->data.result;
+        if (msg->data.result == CURLE_OK)
+            curl_easy_getinfo(request->easy, CURLINFO_RESPONSE_CODE, &request->http_status);
+
+        if (request->attempts <= ctx->retry_cfg.max_retries &&
+            should_retry(request, &ctx->retry_cfg)) {
+            ctx->states[slot] = LAZY_SLOT_RETRY_WAIT;
+            ctx->retry_at_ms[slot] =
+                fast_now_ms() + retry_backoff_ms(&ctx->retry_cfg, request->attempts - 1);
+            continue;
+        }
+
+        VALUE response =
+            (msg->data.result == CURLE_OK)
+                ? build_response(request)
+                : build_error_response_with_code(curl_easy_strerror(msg->data.result),
+                                                 (int)msg->data.result, request->attempts);
+        int stop = record_response(&ctx->cctx, request->index, response);
+        lazy_release_slot(ctx, slot);
+        if (stop)
+            return 1;
+    }
+
+    return 0;
+}
+
+typedef struct {
+    multi_session_t *session;
+    long long wake_at_ms;
+} lazy_poll_args_t;
+
+static void *lazy_poll_without_gvl(void *arg) {
+    lazy_poll_args_t *poll = (lazy_poll_args_t *)arg;
+    multi_session_t *session = poll->session;
+    long long started = fast_now_ms();
+    int before = session->still_running;
+
+    while (!session_cancelled(session)) {
+        int numfds = 0;
+        curl_multi_poll(session->multi, NULL, 0, POLL_TIMEOUT_MS, &numfds);
+        curl_multi_perform(session->multi, &session->still_running);
+
+        if (session->still_running == 0 || session->still_running < before)
+            break;
+        if (poll->wake_at_ms > 0 && fast_now_ms() >= poll->wake_at_ms)
+            break;
+        if (fast_now_ms() - started >= POLL_SLICE_MS)
+            break;
+    }
+
+    return NULL;
+}
+
+static void lazy_wait(lazy_execute_ctx_t *ctx) {
+    long long next_retry = lazy_next_retry_at(ctx);
+
+    if (ctx->session.active_count > 0) {
+        lazy_poll_args_t poll = {.session = &ctx->session, .wake_at_ms = next_retry};
+#ifdef FAST_CURL_HAVE_FIBER_SCHEDULER
+        VALUE scheduler = current_fiber_scheduler();
+        if (scheduler != Qnil)
+            run_via_fiber_worker(scheduler, lazy_poll_without_gvl, &poll);
+        else
+#endif
+            rb_thread_call_without_gvl(lazy_poll_without_gvl, &poll, unblock_perform,
+                                       &ctx->session);
+        return;
+    }
+
+    if (next_retry > 0) {
+        long long delay = next_retry - fast_now_ms();
+        if (delay > 0)
+            retry_delay_sleep((long)delay);
+    }
+}
+
+static int lazy_deadline_reached(lazy_execute_ctx_t *ctx) {
+    if (ctx->opts.deadline_ms <= 0 || fast_now_ms() < ctx->opts.deadline_ms)
+        return 0;
+
+    ctx->deadline_hit = 1;
+    ctx->stop = 1;
+    return 1;
+}
+
+static void lazy_progress(lazy_execute_ctx_t *ctx) {
+    if (ctx->stop || lazy_deadline_reached(ctx))
+        return;
+
+    if (lazy_activate_retries(ctx) || lazy_activate_pending(ctx)) {
+        ctx->stop = 1;
+        return;
+    }
+
+    curl_multi_perform(ctx->session.multi, &ctx->session.still_running);
+    if (lazy_process_completed(ctx)) {
+        ctx->stop = 1;
+        return;
+    }
+
+    if (ctx->occupied_count == 0)
+        return;
+
+    lazy_wait(ctx);
+    if (lazy_process_completed(ctx))
+        ctx->stop = 1;
+}
+
+static VALUE lazy_each_request(VALUE yielded, VALUE arg, int argc, const VALUE *argv,
+                               VALUE blockarg) {
+    (void)blockarg;
+    lazy_execute_ctx_t *ctx = (lazy_execute_ctx_t *)arg;
+    VALUE request = argc == 1 ? argv[0] : yielded;
+
+    while (!ctx->stop && ctx->occupied_count >= ctx->capacity)
+        lazy_progress(ctx);
+
+    if (ctx->stop || lazy_deadline_reached(ctx))
+        rb_iter_break();
 
-            rb_ary_store(cctx.results, i, build_result_pair(i, response));
+    if (ctx->next_index > INT_MAX)
+        rb_raise(rb_eArgError, "lazy request index exceeds supported range");
+
+    int slot = ctx->free_slots[--ctx->free_count];
+    request_ctx_init(&ctx->session.requests[slot], ctx->next_index++);
+    rb_ary_store(ctx->anchors, slot, request);
+    ctx->states[slot] = LAZY_SLOT_PENDING;
+    ctx->occupied_count++;
+    lazy_pending_push(ctx, slot);
+
+    if (lazy_activate_retries(ctx) || lazy_activate_pending(ctx)) {
+        ctx->stop = 1;
+        rb_iter_break();
+    }
+
+    curl_multi_perform(ctx->session.multi, &ctx->session.still_running);
+    if (lazy_process_completed(ctx)) {
+        ctx->stop = 1;
+        rb_iter_break();
+    }
+
+    return Qnil;
+}
+
+static void lazy_finalize_deadline(lazy_execute_ctx_t *ctx) {
+    if (ctx->cctx.stream || ctx->cctx.target > 0)
+        return;
+
+    for (int slot = 0; slot < ctx->capacity; slot++) {
+        if (ctx->states[slot] == LAZY_SLOT_FREE)
+            continue;
+
+        request_ctx_t *request = &ctx->session.requests[slot];
+        if (request->active) {
+            curl_multi_remove_handle(ctx->session.multi, request->easy);
+            request->active = 0;
+            if (ctx->session.active_count > 0)
+                ctx->session.active_count--;
         }
+
+        VALUE response =
+            build_error_response("Total timeout exceeded", ERR_DEADLINE, request->attempts);
+        record_response(&ctx->cctx, request->index, response);
+        lazy_release_slot(ctx, slot);
     }
+}
+
+static VALUE lazy_execute_body(VALUE arg) {
+    lazy_execute_ctx_t *ctx = (lazy_execute_ctx_t *)arg;
 
-    return stream ? Qnil : cctx.results;
+    if (ctx->opts.total_timeout_ms > 0)
+        ctx->opts.deadline_ms = fast_now_ms() + ctx->opts.total_timeout_ms;
+
+    rb_block_call(ctx->source, rb_intern("each"), 0, NULL, lazy_each_request, (VALUE)ctx);
+
+    while (!ctx->stop && ctx->occupied_count > 0)
+        lazy_progress(ctx);
+
+    if (ctx->deadline_hit)
+        lazy_finalize_deadline(ctx);
+
+    RB_GC_GUARD(ctx->source);
+    RB_GC_GUARD(ctx->anchors);
+    return ctx->cctx.stream ? Qnil : ctx->cctx.results;
+}
+
+static VALUE cleanup_lazy_execute(VALUE arg) {
+    lazy_execute_ctx_t *ctx = (lazy_execute_ctx_t *)arg;
+
+    if (ctx->session.requests) {
+        for (int slot = 0; slot < ctx->capacity; slot++) {
+            request_ctx_t *request = &ctx->session.requests[slot];
+            if (request->easy && request->active && ctx->session.multi)
+                curl_multi_remove_handle(ctx->session.multi, request->easy);
+            request_ctx_free(request);
+        }
+        free(ctx->session.requests);
+        ctx->session.requests = NULL;
+    }
+
+    free(ctx->states);
+    ctx->states = NULL;
+    free(ctx->free_slots);
+    ctx->free_slots = NULL;
+    free(ctx->pending_slots);
+    ctx->pending_slots = NULL;
+    free(ctx->retry_at_ms);
+    ctx->retry_at_ms = NULL;
+
+    if (ctx->session.multi) {
+        curl_multi_cleanup(ctx->session.multi);
+        ctx->session.multi = NULL;
+    }
+
+    if (ctx->retry_cfg.retry_http_codes) {
+        free(ctx->retry_cfg.retry_http_codes);
+        ctx->retry_cfg.retry_http_codes = NULL;
+    }
+
+    return Qnil;
+}
+
+static void initialize_lazy_completion(lazy_execute_ctx_t *ctx, VALUE requests, VALUE options,
+                                       int target, int stream, int max_conn) {
+    ctx->capacity = max_conn + ctx->buffer_size;
+    ctx->source = requests;
+    ctx->anchors = rb_ary_new2(ctx->capacity);
+    ctx->next_index = 0;
+
+    ctx->cctx.results = stream ? Qnil : rb_ary_new();
+    ctx->cctx.accept = target > 0 && !NIL_P(options) ? hash_aref_key(options, KEY_ACCEPT) : Qnil;
+    ctx->cctx.completed = 0;
+    ctx->cctx.target = target;
+    ctx->cctx.stream = stream;
+
+    if (!NIL_P(ctx->cctx.accept) && !rb_respond_to(ctx->cctx.accept, rb_intern("call")))
+        rb_raise(rb_eArgError, "accept must respond to #call");
+}
+
+static void allocate_lazy_state(lazy_execute_ctx_t *ctx, int max_conn) {
+    materialize_retry_codes(&ctx->retry_cfg);
+    multi_session_init(&ctx->session, curl_multi_init(), ctx->capacity, max_conn,
+                       ctx->opts.timeout_sec);
+    if (!ctx->session.multi) {
+        cleanup_lazy_execute((VALUE)ctx);
+        rb_raise(rb_eNoMemError, "failed to initialize curl multi handle");
+    }
+    multi_session_configure(ctx->session.multi, max_conn);
+
+    ctx->session.requests = calloc((size_t)ctx->capacity, sizeof(*ctx->session.requests));
+    ctx->states = calloc((size_t)ctx->capacity, sizeof(*ctx->states));
+    ctx->free_slots = malloc(sizeof(*ctx->free_slots) * (size_t)ctx->capacity);
+    ctx->pending_slots = malloc(sizeof(*ctx->pending_slots) * (size_t)ctx->capacity);
+    ctx->retry_at_ms = calloc((size_t)ctx->capacity, sizeof(*ctx->retry_at_ms));
+
+    if (!ctx->session.requests || !ctx->states || !ctx->free_slots || !ctx->pending_slots ||
+        !ctx->retry_at_ms) {
+        cleanup_lazy_execute((VALUE)ctx);
+        rb_raise(rb_eNoMemError, "failed to allocate lazy request state");
+    }
+
+    for (int slot = 0; slot < ctx->capacity; slot++)
+        ctx->free_slots[ctx->free_count++] = slot;
+}
+
+static VALUE internal_lazy_execute(VALUE requests, VALUE options, int target, int stream) {
+    if (!rb_respond_to(requests, rb_intern("each")))
+        rb_raise(rb_eArgError, "requests must be an Array or respond to #each");
+
+    lazy_execute_ctx_t ctx;
+    memset(&ctx, 0, sizeof(ctx));
+
+    int max_conn;
+    parse_options(options, &ctx.opts, &max_conn, &ctx.retry_cfg);
+    parse_retry_codes(options, &ctx.retry_cfg);
+    ctx.buffer_size = NIL_P(options) ? max_conn
+                                     : parse_int_option(options, KEY_BUFFER, "buffer", 1,
+                                                        MAX_BUFFER, max_conn, NULL);
+
+    configure_retry_mode(&ctx.retry_cfg, target, stream);
+    initialize_lazy_completion(&ctx, requests, options, target, stream, max_conn);
+    allocate_lazy_state(&ctx, max_conn);
+
+    return rb_ensure(lazy_execute_body, (VALUE)&ctx, cleanup_lazy_execute, (VALUE)&ctx);
 }
 
 #ifdef FAST_CURL_HAVE_FIBER_SCHEDULER
@@ -1552,7 +2217,7 @@ static VALUE scheduler_execute_thread(void *arg) {
 static void cancel_scheduler_execute(scheduler_execute_ctx_t *ctx) {
     multi_session_t *session = ctx->ea->session;
 
-    session->cancelled = 1;
+    cancel_session(session);
 #ifdef HAVE_CURL_MULTI_WAKEUP
     if (session->multi)
         curl_multi_wakeup(session->multi);
@@ -1597,6 +2262,9 @@ static VALUE execute_with_fiber_scheduler(VALUE arg) {
 #endif
 
 static VALUE internal_execute(VALUE requests, VALUE options, int target, int stream) {
+    if (!RB_TYPE_P(requests, T_ARRAY))
+        return internal_lazy_execute(requests, options, target, stream);
+
     Check_Type(requests, T_ARRAY);
 
     long count_long = RARRAY_LEN(requests);
@@ -1616,57 +2284,17 @@ static VALUE internal_execute(VALUE requests, VALUE options, int target, int str
     int max_conn;
     retry_config_t retry_cfg;
     parse_options(options, &opts, &max_conn, &retry_cfg);
+    parse_retry_codes(options, &retry_cfg);
 
-    for (int i = 0; i < count; i++) {
-        request_ctx_t probe;
-        request_ctx_init(&probe, i);
-        if (!request_ctx_prepare_easy(&probe)) {
-            request_ctx_free(&probe);
-            continue;
-        }
-        setup_easy_handle(&probe, rb_ary_entry(requests, i), &opts);
-        int fatal = probe.setup_error_fatal;
-        const char *message = probe.setup_error;
-        char buffer[128];
-        if (fatal && message) {
-            snprintf(buffer, sizeof(buffer), "%s (request %d)", message, i);
-        }
-        request_ctx_free(&probe);
-        if (fatal) {
-            VALUE klass = NIL_P(fast_validation_error) ? rb_eArgError : fast_validation_error;
-            rb_raise(klass, "%s", buffer);
-        }
-    }
-
-    if (stream || target > 0) {
-        if (retry_cfg.retries_explicit && retry_cfg.max_retries > 0 && stream)
-            rb_warn(
-                "FastCurl: retries are not supported in stream_execute, ignoring retries option");
-        if (retry_cfg.retries_explicit && retry_cfg.max_retries > 0 && target > 0)
-            rb_warn(
-                "FastCurl: retries are not supported in first_execute, ignoring retries option");
-        retry_cfg.max_retries = 0;
-    }
+    validate_execute_requests(requests, count, target, options, &opts);
+    configure_retry_mode(&retry_cfg, target, stream);
 
+    materialize_retry_codes(&retry_cfg);
     multi_session_t session;
     int *invalid = NULL;
-    multi_session_init(&session, curl_multi_init(), count, max_conn, opts.timeout_sec);
-
-    cleanup_ctx_t cleanup = {.session = &session, .invalid = NULL, .retry_cfg = &retry_cfg};
-
-    if (!session.multi)
-        cleanup_and_raise(&cleanup, rb_eNoMemError, "failed to initialize curl multi handle");
-
-    multi_session_configure(session.multi, max_conn);
-
-    session.requests = calloc((size_t)count, sizeof(request_ctx_t));
-    if (!session.requests)
-        cleanup_and_raise(&cleanup, rb_eNoMemError, "failed to allocate request contexts");
-
-    invalid = calloc((size_t)count, sizeof(int));
-    cleanup.invalid = invalid;
-    if (!invalid)
-        cleanup_and_raise(&cleanup, rb_eNoMemError, "failed to allocate tracking array");
+    cleanup_ctx_t cleanup = {0};
+    prepare_execute_session(&session, &invalid, &cleanup, &retry_cfg, count, max_conn,
+                            opts.timeout_sec);
     execute_args_t ea = {
         .requests = requests,
         .options = options,
@@ -1680,7 +2308,8 @@ static VALUE internal_execute(VALUE requests, VALUE options, int target, int str
 
 #ifdef FAST_CURL_HAVE_FIBER_SCHEDULER
     VALUE scheduler = current_fiber_scheduler();
-    if (scheduler != Qnil && !stream) {
+    VALUE accept = target > 0 && !NIL_P(options) ? hash_aref_key(options, KEY_ACCEPT) : Qnil;
+    if (scheduler != Qnil && !stream && NIL_P(accept)) {
         scheduler_execute_ctx_t scheduler_ctx = {
             .ea = &ea,
             .scheduler = scheduler,