starvla: remove unused runtime fallbacks

Author: JJJYmmm

src/models/starvla/fast_codec.cpp

@@ -1,25 +1,15 @@
 #include "models/starvla/fast_codec.h"
 
-#include "nlohmann/json.hpp"
-
 #include <algorithm>
-#include <array>
 #include <cmath>
-#include <exception>
-#include <fstream>
 #include <limits>
-#include <sstream>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
 
 namespace robotcpp::starvla {
 namespace {
 
-using Json = nlohmann::json;
-
-constexpr size_t kMaximumJsonBytes = 16U * 1024U * 1024U;
-constexpr size_t kOfficialVocabSize = 2048U;
 constexpr size_t kMaximumVocabSize = 65536U;
 constexpr size_t kMaximumTimeHorizon = 1024U;
 constexpr size_t kMaximumActionDim = 1024U;
@@ -29,56 +19,8 @@ constexpr size_t kMaximumGeneratedSequence = 2048U;
 constexpr size_t kMaximumDecodedBytes = 1024U * 1024U;
 constexpr size_t kMaximumOutputScalars = 16U * 1024U * 1024U;
 constexpr uint64_t kMaximumIdctMultiplyAdds = 64ULL * 1024ULL * 1024ULL;
-constexpr const char * kActionTokenPrefix = "<robot_action_";
 constexpr double kPi = 3.141592653589793238462643383279502884;
 
-bool read_json(const std::filesystem::path & path, Json & output, std::string & error) {
-    std::error_code filesystem_error;
-    const uintmax_t size = std::filesystem::file_size(path, filesystem_error);
-    if (filesystem_error) {
-        error = "cannot stat StarVLA FAST JSON asset '" + path.string() + "': " +
-                filesystem_error.message();
-        return false;
-    }
-    if (size > kMaximumJsonBytes) {
-        error = "StarVLA FAST JSON asset exceeds the 16 MiB limit: " + path.string();
-        return false;
-    }
-
-    std::ifstream stream(path, std::ios::binary);
-    if (!stream) {
-        error = "cannot open StarVLA FAST JSON asset: " + path.string();
-        return false;
-    }
-    std::string contents;
-    contents.reserve(static_cast<size_t>(size));
-    std::array<char, 64U * 1024U> buffer{};
-    while (stream) {
-        stream.read(buffer.data(), static_cast<std::streamsize>(buffer.size()));
-        const std::streamsize count = stream.gcount();
-        if (count <= 0) {
-            continue;
-        }
-        const size_t chunk_size = static_cast<size_t>(count);
-        if (contents.size() > kMaximumJsonBytes - chunk_size) {
-            error = "StarVLA FAST JSON asset exceeds the 16 MiB limit while reading: " +
-                    path.string();
-            return false;
-        }
-        contents.append(buffer.data(), chunk_size);
-    }
-    if (!stream.eof() || stream.bad()) {
-        error = "cannot read StarVLA FAST JSON asset: " + path.string();
-        return false;
-    }
-    output = Json::parse(contents, nullptr, false);
-    if (output.is_discarded()) {
-        error = "cannot parse StarVLA FAST JSON asset: " + path.string();
-        return false;
-    }
-    return true;
-}
-
 bool decode_utf8_strict(const std::string & input, std::vector<uint32_t> & output,
                         std::string & error) {
     output.clear();
@@ -258,200 +200,6 @@ void decode_utf8_lossy(const std::vector<uint8_t> & input, std::vector<uint32_t>
     }
 }
 
-bool parse_positive_size(const Json & value, const char * name, size_t & output,
-                         std::string & error) {
-    if (!value.is_number_integer()) {
-        error = std::string("StarVLA FAST ") + name + " must be an integer";
-        return false;
-    }
-    try {
-        const int64_t parsed = value.get<int64_t>();
-        if (parsed <= 0 || static_cast<uint64_t>(parsed) >
-                               static_cast<uint64_t>(std::numeric_limits<size_t>::max())) {
-            error = std::string("StarVLA FAST ") + name + " is out of range";
-            return false;
-        }
-        output = static_cast<size_t>(parsed);
-        return true;
-    } catch (const std::exception &) {
-        error = std::string("StarVLA FAST ") + name + " is out of range";
-        return false;
-    }
-}
-
-bool parse_processor_config(const Json & json, size_t time_horizon_override,
-                            size_t action_dim_override, FastCodecConfig & config,
-                            std::string & error) {
-    if (!json.is_object() || !json.contains("processor_class") ||
-        json["processor_class"] != "UniversalActionProcessor" || !json.contains("scale") ||
-        !json["scale"].is_number() || !json.contains("vocab_size") ||
-        !json.contains("min_token") || !json["min_token"].is_number_integer()) {
-        error = "StarVLA FAST processor_config.json has an incompatible schema";
-        return false;
-    }
-    config.scale = json["scale"].get<double>();
-    if (!std::isfinite(config.scale) || config.scale == 0.0) {
-        error = "StarVLA FAST processor scale must be finite and non-zero";
-        return false;
-    }
-    if (!parse_positive_size(json["vocab_size"], "vocab_size", config.vocab_size, error)) {
-        return false;
-    }
-    if (config.vocab_size != kOfficialVocabSize) {
-        error = "StarVLA FAST pinned vocabulary must contain exactly 2048 tokens";
-        return false;
-    }
-    try {
-        if (json["min_token"].is_number_unsigned()) {
-            const uint64_t min_token = json["min_token"].get<uint64_t>();
-            if (min_token > static_cast<uint64_t>(std::numeric_limits<int32_t>::max())) {
-                error = "StarVLA FAST min_token is out of int32 range";
-                return false;
-            }
-            config.min_token = static_cast<int32_t>(min_token);
-        } else {
-            const int64_t min_token = json["min_token"].get<int64_t>();
-            if (min_token < std::numeric_limits<int32_t>::min() ||
-                min_token > std::numeric_limits<int32_t>::max()) {
-                error = "StarVLA FAST min_token is out of int32 range";
-                return false;
-            }
-            config.min_token = static_cast<int32_t>(min_token);
-        }
-    } catch (const std::exception &) {
-        error = "StarVLA FAST min_token is out of int32 range";
-        return false;
-    }
-
-    auto choose_dimension = [&](const char * name, size_t override_value, size_t & target) {
-        if (override_value != 0) {
-            target = override_value;
-            return true;
-        }
-        if (!json.contains(name) || json[name].is_null()) {
-            error = std::string("StarVLA FAST ") + name +
-                    " is absent; pass the policy dimension explicitly";
-            return false;
-        }
-        return parse_positive_size(json[name], name, target, error);
-    };
-    return choose_dimension("time_horizon", time_horizon_override, config.time_horizon) &&
-           choose_dimension("action_dim", action_dim_override, config.action_dim);
-}
-
-bool parse_tokenizer_vocab(const Json & json, size_t expected_vocab_size,
-                           std::vector<std::string> & vocab_by_id, std::string & error) {
-    if (!json.is_object() || !json.contains("version") || json["version"] != "1.0" ||
-        !json.contains("added_tokens") || !json["added_tokens"].is_array() ||
-        !json["added_tokens"].empty() || !json.contains("decoder") ||
-        !json["decoder"].is_object() || !json["decoder"].contains("type") ||
-        json["decoder"]["type"] != "ByteLevel" || !json.contains("model") ||
-        !json["model"].is_object() || !json["model"].contains("type") ||
-        json["model"]["type"] != "BPE" || !json["model"].contains("vocab") ||
-        !json["model"]["vocab"].is_object()) {
-        error = "StarVLA FAST tokenizer.json is not the required ByteLevel BPE schema";
-        return false;
-    }
-    const Json & decoder = json["decoder"];
-    if (decoder.size() != 4 || !decoder.contains("add_prefix_space") ||
-        decoder["add_prefix_space"] != true || !decoder.contains("trim_offsets") ||
-        decoder["trim_offsets"] != true || !decoder.contains("use_regex") ||
-        decoder["use_regex"] != true) {
-        error = "StarVLA FAST tokenizer.json has an incompatible ByteLevel decoder contract";
-        return false;
-    }
-    const Json & vocab = json["model"]["vocab"];
-    if (vocab.size() != expected_vocab_size) {
-        error = "StarVLA FAST tokenizer vocabulary size does not match processor_config.json";
-        return false;
-    }
-    vocab_by_id.assign(expected_vocab_size, std::string());
-    std::vector<bool> seen(expected_vocab_size, false);
-    for (auto iterator = vocab.begin(); iterator != vocab.end(); ++iterator) {
-        if (!iterator.value().is_number_integer()) {
-            error = "StarVLA FAST tokenizer vocabulary ID is not an integer";
-            return false;
-        }
-        int64_t token_id = -1;
-        try {
-            token_id = iterator.value().get<int64_t>();
-        } catch (const std::exception &) {
-            error = "StarVLA FAST tokenizer vocabulary ID is out of range";
-            return false;
-        }
-        if (token_id < 0 || static_cast<uint64_t>(token_id) >= expected_vocab_size ||
-            seen[static_cast<size_t>(token_id)]) {
-            error = "StarVLA FAST tokenizer vocabulary IDs are not a bijection";
-            return false;
-        }
-        seen[static_cast<size_t>(token_id)] = true;
-        vocab_by_id[static_cast<size_t>(token_id)] = iterator.key();
-    }
-    return true;
-}
-
-bool parse_action_index(const std::string & value, size_t & index) {
-    const std::string prefix(kActionTokenPrefix);
-    if (value.size() <= prefix.size() + 1 || value.compare(0, prefix.size(), prefix) != 0 ||
-        value.back() != '>') {
-        return false;
-    }
-    const std::string digits = value.substr(prefix.size(), value.size() - prefix.size() - 1);
-    if (digits.empty() || (digits.size() > 1 && digits.front() == '0')) {
-        return false;
-    }
-    size_t parsed = 0;
-    for (char character : digits) {
-        if (character < '0' || character > '9') {
-            return false;
-        }
-        const size_t digit = static_cast<size_t>(character - '0');
-        if (parsed > (std::numeric_limits<size_t>::max() - digit) / 10U) {
-            return false;
-        }
-        parsed = parsed * 10U + digit;
-    }
-    index = parsed;
-    return true;
-}
-
-bool parse_action_map(const Json & json, size_t vocab_size,
-                      std::vector<int32_t> & fast_to_vlm, std::string & error) {
-    if (!json.is_object() || json.size() != vocab_size) {
-        error = "StarVLA FAST action-token map must contain exactly one entry per FAST token";
-        return false;
-    }
-    fast_to_vlm.assign(vocab_size, -1);
-    std::vector<bool> seen(vocab_size, false);
-    std::unordered_set<int32_t> vlm_ids;
-    for (auto iterator = json.begin(); iterator != json.end(); ++iterator) {
-        size_t fast_id = 0;
-        if (!parse_action_index(iterator.key(), fast_id) || fast_id >= vocab_size || seen[fast_id]) {
-            error = "StarVLA FAST action-token map has a malformed or duplicate token name";
-            return false;
-        }
-        if (!iterator.value().is_number_integer()) {
-            error = "StarVLA FAST action-token map contains a non-integer VLM ID";
-            return false;
-        }
-        int64_t vlm_id = -1;
-        try {
-            vlm_id = iterator.value().get<int64_t>();
-        } catch (const std::exception &) {
-            error = "StarVLA FAST action-token VLM ID is out of range";
-            return false;
-        }
-        if (vlm_id < 0 || vlm_id > std::numeric_limits<int32_t>::max() ||
-            !vlm_ids.insert(static_cast<int32_t>(vlm_id)).second) {
-            error = "StarVLA FAST action-token VLM IDs must be unique non-negative int32 values";
-            return false;
-        }
-        seen[fast_id] = true;
-        fast_to_vlm[fast_id] = static_cast<int32_t>(vlm_id);
-    }
-    return true;
-}
-
 bool checked_action_count(const FastCodecConfig & config, size_t batch_size,
                           size_t & per_sample, size_t & total, std::string & error) {
     if (config.vocab_size > kMaximumVocabSize || config.time_horizon > kMaximumTimeHorizon ||
@@ -602,34 +350,6 @@ std::unique_ptr<FastCodec> FastCodec::create_compiled(
         new FastCodec(config, std::move(pieces), std::move(fast_to_vlm_id)));
 }
 
-std::unique_ptr<FastCodec> FastCodec::load_hf_assets(
-    const std::filesystem::path & tokenizer_json,
-    const std::filesystem::path & processor_config_json,
-    const std::filesystem::path & action_token_map_json,
-    size_t time_horizon, size_t action_dim, std::string & error) {
-    error.clear();
-    Json processor;
-    Json tokenizer;
-    Json action_map;
-    if (!read_json(processor_config_json, processor, error) ||
-        !read_json(tokenizer_json, tokenizer, error) ||
-        !read_json(action_token_map_json, action_map, error)) {
-        return nullptr;
-    }
-
-    FastCodecConfig config;
-    std::vector<std::string> vocab_by_id;
-    std::vector<int32_t> fast_to_vlm;
-    size_t per_sample = 0;
-    size_t total = 0;
-    if (!parse_processor_config(processor, time_horizon, action_dim, config, error) ||
-        !checked_action_count(config, 1, per_sample, total, error) ||
-        !parse_tokenizer_vocab(tokenizer, config.vocab_size, vocab_by_id, error) ||
-        !parse_action_map(action_map, config.vocab_size, fast_to_vlm, error)) {
-        return nullptr;
-    }
-    return create(config, std::move(vocab_by_id), std::move(fast_to_vlm), error);
-}
 
 const FastCodecConfig & FastCodec::config() const {
     return config_;

src/models/starvla/fast_codec.h

@@ -2,7 +2,6 @@
 
 #include <cstddef>
 #include <cstdint>
-#include <filesystem>
 #include <memory>
 #include <string>
 #include <utility>
@@ -39,12 +38,6 @@ class FastCodec {
         std::vector<uint8_t> token_bytes,
         std::vector<int32_t> fast_to_vlm_id, std::string & error);
 
-    static std::unique_ptr<FastCodec> load_hf_assets(
-        const std::filesystem::path & tokenizer_json,
-        const std::filesystem::path & processor_config_json,
-        const std::filesystem::path & action_token_map_json,
-        size_t time_horizon, size_t action_dim, std::string & error);
-
     const FastCodecConfig & config() const;
     const std::vector<int32_t> & fast_to_vlm_ids() const;
 

src/models/starvla/qwen3vl_bridge.h

@@ -177,8 +177,4 @@ class Qwen3VLBridge {
 
 // Neutral aliases for new callers. The original names remain the ABI/source
 // compatibility surface for the completed Qwen3 integrations.
-using QwenVLImageView = Qwen3VLImageView;
-using QwenVLBridgeConfig = Qwen3VLBridgeConfig;
-using QwenVLBridge = Qwen3VLBridge;
-
 } // namespace robotcpp::starvla

src/models/starvla/starvla_engine.cpp

@@ -342,7 +342,6 @@ bool prepare_pi_qwen_images(
 } // namespace
 
 struct StarVLAEngine::Impl {
-    StarVLAEngineConfig options;
     StarVLAVariant variant = StarVLAVariant::qwen3_oft;
     std::filesystem::path policy_path;
     std::filesystem::path text_path;
@@ -376,7 +375,6 @@ std::unique_ptr<StarVLAEngine> StarVLAEngine::load(const StarVLAEngineConfig & c
     }
 
     std::unique_ptr<Impl> impl(new Impl());
-    impl->options = config;
     const int effective_threads = config.n_threads > 0 ? config.n_threads : kDefaultThreadCount;
     impl->policy_path = std::filesystem::path(config.policy_path);
     if (!require_regular_file(impl->policy_path, "policy GGUF", error)) {

tools/hf2gguf/starvla/generate_starvla_groot_golden.py

@@ -9,7 +9,6 @@
 import hashlib
 import importlib.metadata
 import json
-import os
 import platform
 import random
 import shutil
@@ -25,7 +24,7 @@
 if str(TOOLS_DIR) not in sys.path:
     sys.path.insert(0, str(TOOLS_DIR))
 
-from generate_starvla_pi_v3_golden import (  # noqa: E402
+from generate_starvla_pi_v3_golden import (  # noqa: E402,F401
     EXPECTED_ACCELERATE_VERSION,
     EXPECTED_DIFFUSERS_VERSION,
     EXPECTED_NUMPY_VERSION,

tools/hf2gguf/starvla/validate_starvla_bundle.py

@@ -4,7 +4,6 @@
 from __future__ import annotations
 
 import argparse
-import hashlib
 import json
 import math
 import sys
@@ -16,7 +15,6 @@
 
 from convert_starvla_policy_to_gguf import (
     GROOT_BLOCK_COUNT,
-    GROOT_OFFICIAL_DIMENSIONS,
     GROOT_OFFICIAL_DIMENSIONS_BY_BACKBONE,
     GROOT_POLICY_TENSOR_COUNT,
     GROOT_TENSOR_MAP,