Function run_model_step_impl

app/workflow/workflow.cpp:579–658

    }
    if (fallback.threads <= 0) {
        throw std::runtime_error("workflow step threads must be positive");
    }
    return fallback;
}

void run_model_step_impl(
    const engine::runtime::ModelRegistry & registry,
    const engine::io::json::Value & step,
    const WorkflowRunOptions & options,
    WorkflowContext & context) {
    const std::string id = workflow_string(step, "id");
    const auto request_value = step.find("request");
    if (request_value == nullptr || request_value->is_null()) {
        throw std::runtime_error("model step requires request object: " + id);
    }

    engine::runtime::ModelLoadRequest load_request;
    load_request.model_path = resolve_workflow_path(workflow_string(step, "model"), context);
    load_request.model_spec_override = options.model_spec_override;
    if (const auto family = workflow_optional_string(step, "family")) {
        load_request.family_hint = *family;
    }
    if (const auto config = workflow_optional_string(step, "config")) {
        load_request.config_id = *config;
    }
    if (const auto weight = workflow_optional_string(step, "weight")) {
        load_request.weight_id = *weight;
    }
    load_request.options = merged_options(options.load_options, step.find("load_options"), context);

    engine::runtime::SessionOptions session_options;
    session_options.backend = parse_step_backend(step, options.backend);
    session_options.options = merged_options(options.session_options, step.find("session_options"), context);

    const engine::runtime::TaskSpec task_spec{
        engine::runtime::parse_voice_task_kind(workflow_string(step, "task")),
        engine::runtime::parse_run_mode(workflow_string_or(step, "mode", "offline")),
    };
    if (task_spec.mode != engine::runtime::RunMode::Offline) {
        throw std::runtime_error("workflow model steps currently require offline mode: " + id);
    }

    auto model = registry.load(load_request);
    auto session = model->create_task_session(task_spec, session_options);
    auto * offline = dynamic_cast<engine::runtime::IOfflineVoiceTaskSession *>(session.get());
    if (offline == nullptr) {
        throw std::runtime_error("workflow model step does not support offline execution: " + id);
    }

    const auto expanded_request = expanded_json(*request_value, context);
    auto request = minitts::cli::build_request_from_json(expanded_request, context.workflow_dir);
    const auto text_out_value = workflow_optional_string(step, "text_out");
    const auto words_out_value = workflow_optional_string(step, "words_out");
    std::optional<std::filesystem::path> text_out;
    std::optional<std::filesystem::path> words_out;
    if (text_out_value.has_value()) {
        text_out = resolve_workflow_path(*text_out_value, context);
    }