Method run_step_into

src/models/ace_step/planner.cpp:1998–2047

        return step_cache_.export_state();
    }

    void run_step_into(
        int32_t token,
        std::vector<float> & logits,
        const std::vector<int32_t> * visible_prefix = nullptr) {
        const auto & config = runtime_->assets().config.planner;
        if (step_cache_.valid_steps() >= cache_steps_) {
            throw std::runtime_error("ACE-Step planner decode cache exhausted");
        }
        ggml_backend_tensor_set(token_id_, &token, 0, sizeof(int32_t));
        const int32_t position = static_cast<int32_t>(step_cache_.current_end());
        if (visible_prefix != nullptr &&
            static_cast<int64_t>(visible_prefix->size()) != step_cache_.current_end()) {
            throw std::runtime_error("ACE-Step planner decode visible-prefix length mismatch");
        }
        ggml_backend_tensor_set(positions_, &position, 0, sizeof(int32_t));
        const auto masked = ggml_fp32_to_fp16(-std::numeric_limits<float>::infinity());
        const auto visible = ggml_fp32_to_fp16(0.0F);
        std::fill(attention_mask_values_.begin(), attention_mask_values_.end(), masked);
        if (visible_prefix != nullptr) {
            for (int64_t i = 0; i < step_cache_.valid_steps(); ++i) {
                if ((*visible_prefix)[static_cast<size_t>(i)] != 0) {
                    attention_mask_values_[static_cast<size_t>(i)] = visible;
                }
            }
        } else {
            for (int64_t i = 0; i < step_cache_.valid_steps(); ++i) {
                attention_mask_values_[static_cast<size_t>(i)] = visible;
            }
        }
        attention_mask_values_[static_cast<size_t>(cache_steps_)] = visible;
        ggml_backend_tensor_set(
            attention_mask_,
            attention_mask_values_.data(),
            0,
            attention_mask_values_.size() * sizeof(ggml_fp16_t));
        core::set_backend_threads(runtime_->backend(), runtime_->threads());
        const ggml_status status = engine::core::compute_backend_graph(runtime_->backend(), graph_);
        ggml_backend_synchronize(runtime_->backend());
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("ACE-Step planner decode graph compute failed");
        }
        logits.resize(static_cast<size_t>(config.vocab_size));
        ggml_backend_tensor_get(logits_, logits.data(), 0, logits.size() * sizeof(float));
        const size_t dst_slot = static_cast<size_t>(step_cache_.valid_steps());
        for (size_t layer = 0; layer < key_sources_.size(); ++layer) {
            ggml_backend_tensor_copy(key_sources_[layer], key_destinations_[dst_slot][layer]);
            ggml_backend_tensor_copy(value_sources_[layer], value_destinations_[dst_slot][layer]);
        }
        step_cache_.advance_after_direct_append(1);
    }

private: