Function client_main

ds4_server.c:11247–11345

}

static int server_multimodal_resume_pos(ds4_session *session,
                                        const ds4_tokens *prompt,
                                        const ds4_vision_span *images,
                                        size_t image_count) {
    if (!session || !prompt) return 0;
    const int live = ds4_session_pos(session);
    const int common = ds4_session_common_prefix(session, prompt);
    return server_multimodal_resume_frontier(
        live, common, prompt->len,
        ds4_session_vision_state_matches(session, images, image_count));
}

static int server_session_sync_multimodal(server *s, server_slot *slot,
                                          const ds4_tokens *prompt,
                                          const ds4_vision_span *images,
                                          size_t image_count,
                                          char *err, size_t errlen) {
    if (!image_count)
        return server_session_sync(s, slot, prompt, err, errlen);
    if (!s || !slot || !prompt || !images) return 1;
    if (!s->batched_mode) {
        if (!server_prefill_enter(s, slot)) return DS4_SESSION_SYNC_INTERRUPTED;
        int rc = ds4_session_sync_multimodal(slot->session, prompt,
                                             images, image_count,
                                             err, errlen);
        server_prefill_leave(s);
        return rc;
    }

    /* Start at the exact live frontier when both tokens and image identities
     * match. Starting at zero made the first scheduling slice truncate a
     * perfectly reusable long checkpoint, forcing a complete refill. */
    pthread_mutex_lock(&s->inference_mu);
    int done = server_multimodal_resume_pos(slot->session, prompt,
                                            images, image_count);
    pthread_mutex_unlock(&s->inference_mu);
    bool called = false;
    while (!g_stop_requested && !slot_job_cancelled(slot) &&
           (!called || done < prompt->len)) {
        int quantum = server_prefill_quantum(s);
        int target = done + quantum;
        if (target > prompt->len || target < done) target = prompt->len;
        if (target <= 0) target = prompt->len;
        for (size_t i = 0; i < image_count; i++) {
            uint64_t end = (uint64_t)images[i].token_start +
                           images[i].embedding.token_count;
            if ((uint64_t)target > images[i].token_start &&
                (uint64_t)target < end) {
                target = end > (uint64_t)prompt->len ? prompt->len : (int)end;
            }
        }
        size_t prefix_images = 0;
        while (prefix_images < image_count) {
            uint64_t end = (uint64_t)images[prefix_images].token_start +
                           images[prefix_images].embedding.token_count;
            if (end > (uint64_t)target) break;
            prefix_images++;
        }