arcane-os 0.94.0 → 0.96.0

package/src/local-ai/magpie/native/main.cpp

@@ -0,0 +1,270 @@
+#include <nemo_speech/tts.h>
+
+#include <atomic>
+#include <condition_variable>
+#include <cstdint>
+#include <exception>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#endif
+
+namespace {
+
+using Synthesizer = std::unique_ptr<nemo_speech_tts_synthesizer, decltype(&nemo_speech_tts_destroy)>;
+
+struct Utterance {
+    uint64_t id;
+    int32_t speaker;
+    std::string language;
+    std::string text;
+    std::atomic<bool> cancelled{false};
+};
+
+std::mutex output_mutex;
+
+// Lengths belong only to this binary transport. Every PCM and text frame is complete.
+void emit(const char* kind, uint64_t id, const char* content, size_t length) {
+    const std::lock_guard<std::mutex> lock(output_mutex);
+    std::cout << kind << '\t' << id << '\t' << length << '\n';
+    std::cout.write(content, static_cast<std::streamsize>(length));
+    std::cout.flush();
+    if (!std::cout) throw std::runtime_error("The Magpie output pipe closed.");
+}
+
+void emit(const char* kind, uint64_t id, const std::string& content = {}) {
+    emit(kind, id, content.data(), content.size());
+}
+
+struct Output {
+    Utterance& utterance;
+    std::string error;
+};
+
+bool deliver_audio(const uint8_t* pcm, size_t length, void* context) {
+    auto& output = *static_cast<Output*>(context);
+    if (output.utterance.cancelled.load()) return false;
+    try {
+        emit("audio", output.utterance.id, reinterpret_cast<const char*>(pcm), length);
+        return !output.utterance.cancelled.load();
+    } catch (const std::exception& error) {
+        output.error = error.what();
+        return false;
+    }
+}
+
+std::string read_text(size_t length) {
+    std::string text(length, '\0');
+    if (!std::cin.read(text.data(), static_cast<std::streamsize>(length))) {
+        throw std::runtime_error("The Magpie input pipe ended during a text frame.");
+    }
+    return text;
+}
+
+int serve(const std::vector<std::string>& arguments) {
+#ifdef _WIN32
+    _setmode(_fileno(stdin), _O_BINARY);
+    _setmode(_fileno(stdout), _O_BINARY);
+#endif
+    if (arguments.size() != 6) {
+        throw std::runtime_error("Usage: arcane-magpie MAGPIE.gguf CODEC.gguf TOKENIZER_DIR SPEAKER cpu|cuda");
+    }
+    const std::string& backend = arguments[5];
+    if (backend != "cpu" && backend != "cuda") {
+        throw std::runtime_error("Select the prepared CPU or CUDA TTS backend explicitly.");
+    }
+    nemo_speech_tts_model_config models = {};
+    models.size = sizeof(models);
+    models.magpie_model = arguments[1].c_str();
+    models.codec_model = arguments[2].c_str();
+    models.tokenizer_model_dir = arguments[3].c_str();
+    // Leave optional written-to-spoken normalization absent: the caller owns its text.
+    auto runtime = nemo_speech_tts_runtime_config_default();
+    runtime.speaker = std::stoi(arguments[4]);
+    runtime.lt_backend = backend == "cuda" ? NEMO_SPEECH_TTS_BACKEND_CUDA : NEMO_SPEECH_TTS_BACKEND_CPU;
+    runtime.sampling_backend = runtime.lt_backend;
+    runtime.codec_cpu = backend == "cpu";
+    nemo_speech_tts_synthesizer_config configuration = {};
+    configuration.size = sizeof(configuration);
+    configuration.model = &models;
+    configuration.runtime = &runtime;
+    nemo_speech_tts_synthesizer* raw = nullptr;
+    if (nemo_speech_tts_create(&configuration, &raw) != NEMO_SPEECH_TTS_OK) {
+        const char* error = nemo_speech_tts_last_error();
+        throw std::runtime_error(error && *error ? error : "The native TTS model creation failed without an error message.");
+    }
+    const Synthesizer synthesizer(raw, nemo_speech_tts_destroy);
+    emit("ready", 0, std::to_string(nemo_speech_tts_sample_rate(synthesizer.get())));
+
+    std::mutex work_mutex;
+    std::condition_variable work_ready;
+    std::shared_ptr<Utterance> pending;
+    std::shared_ptr<Utterance> active;
+    bool closing = false;
+    std::exception_ptr worker_error;
+
+    // Only this worker calls the synthesizer. The reader can flag the exact
+    // active utterance while inference or PCM backpressure occupies that worker.
+    std::thread worker([&]() {
+        try {
+            for (;;) {
+                std::shared_ptr<Utterance> utterance;
+                {
+                    std::unique_lock<std::mutex> lock(work_mutex);
+                    work_ready.wait(lock, [&]() { return closing || pending != nullptr; });
+                    if (!pending) return;
+                    utterance = std::move(pending);
+                    active = utterance;
+                }
+                auto options = nemo_speech_tts_synthesis_options_default();
+                const std::string request_id = std::to_string(utterance->id);
+                options.request_id = request_id.c_str();
+                options.language_code = utterance->language.c_str();
+                options.speaker = utterance->speaker;
+                Output output{*utterance, {}};
+                nemo_speech_tts_status status = NEMO_SPEECH_TTS_ERROR_CANCELLED;
+                if (!utterance->cancelled.load()) {
+                    emit("started", utterance->id);
+                    status = nemo_speech_tts_synthesize_text(
+                        synthesizer.get(), &options, utterance->text.c_str(), deliver_audio, &output, nullptr
+                    );
+                }
+                // Read the thread-local native error before any other native call.
+                std::string native_error;
+                if (status != NEMO_SPEECH_TTS_OK && status != NEMO_SPEECH_TTS_ERROR_CANCELLED) {
+                    const char* message = nemo_speech_tts_last_error();
+                    native_error = message && *message ? message
+                        : "The native TTS call failed with status " + std::to_string(status) + ".";
+                }
+                {
+                    const std::lock_guard<std::mutex> lock(work_mutex);
+                    active.reset();
+                }
+                if (!output.error.empty()) emit("error", utterance->id, output.error);
+                else if (!native_error.empty()) emit("error", utterance->id, native_error);
+                else if (utterance->cancelled.load() || status == NEMO_SPEECH_TTS_ERROR_CANCELLED) {
+                    emit("cancelled", utterance->id);
+                } else emit("done", utterance->id);
+            }
+        } catch (...) {
+            const auto failure = std::current_exception();
+            {
+                const std::lock_guard<std::mutex> lock(work_mutex);
+                worker_error = failure;
+                closing = true;
+            }
+            // A failed worker must wake the process owner, which closes input
+            // and joins this process instead of leaving an unanswered request.
+            try {
+                try { std::rethrow_exception(failure); }
+                catch (const std::exception& error) { emit("fatal", 0, error.what()); }
+                catch (...) { emit("fatal", 0, "The native synthesis worker raised an unknown exception."); }
+            } catch (...) {
+                // A closed output pipe cannot carry another diagnostic.
+            }
+        }
+    });
+
+    std::exception_ptr reader_error;
+    try {
+        std::string line;
+        while (std::getline(std::cin, line)) {
+            std::istringstream command(line);
+            std::string operation;
+            uint64_t id = 0;
+            if (!(command >> operation >> id)) throw std::runtime_error("Unreadable Magpie command.");
+            if (operation == "synthesize") {
+                int32_t speaker = 0;
+                size_t language_length = 0;
+                size_t text_length = 0;
+                if (!(command >> speaker >> language_length >> text_length)) {
+                    throw std::runtime_error("Unreadable Magpie synthesis framing.");
+                }
+                auto utterance = std::make_shared<Utterance>();
+                utterance->id = id;
+                utterance->speaker = speaker;
+                utterance->language = read_text(language_length);
+                utterance->text = read_text(text_length);
+                if (utterance->language.find('\0') != std::string::npos || utterance->text.find('\0') != std::string::npos) {
+                    emit("error", id, "The public TTS text interface cannot consume embedded NUL characters.");
+                    continue;
+                }
+                {
+                    const std::lock_guard<std::mutex> lock(work_mutex);
+                    if (worker_error) std::rethrow_exception(worker_error);
+                    if (closing || pending || active) {
+                        emit("error", id, "The native synthesizer already owns an utterance.");
+                        continue;
+                    }
+                    pending = utterance;
+                }
+                work_ready.notify_one();
+            } else if (operation == "stop") {
+                const std::lock_guard<std::mutex> lock(work_mutex);
+                if (pending && pending->id == id) pending->cancelled.store(true);
+                if (active && active->id == id) active->cancelled.store(true);
+            } else if (operation == "close") {
+                break;
+            } else {
+                emit("error", id, "Unknown Magpie command.");
+            }
+        }
+    } catch (...) {
+        reader_error = std::current_exception();
+    }
+    {
+        const std::lock_guard<std::mutex> lock(work_mutex);
+        closing = true;
+        if (pending) pending->cancelled.store(true);
+        if (active) active->cancelled.store(true);
+    }
+    work_ready.notify_one();
+    worker.join();
+    if (reader_error) std::rethrow_exception(reader_error);
+    if (worker_error) std::rethrow_exception(worker_error);
+    return 0;
+}
+
+int run(const std::vector<std::string>& arguments) {
+    try {
+        return serve(arguments);
+    } catch (const std::exception& error) {
+        std::cerr << error.what() << '\n';
+        return 1;
+    }
+}
+
+} // namespace
+
+#ifdef _WIN32
+int wmain(int argc, wchar_t** argv) {
+    std::vector<std::string> arguments;
+    for (int index = 0; index < argc; ++index) {
+        const int length = WideCharToMultiByte(CP_UTF8, 0, argv[index], -1, nullptr, 0, nullptr, nullptr);
+        if (length == 0) {
+            std::cerr << "Windows could not encode the selected TTS argument as UTF-8.\n";
+            return 1;
+        }
+        std::string value(length, '\0');
+        WideCharToMultiByte(CP_UTF8, 0, argv[index], -1, value.data(), length, nullptr, nullptr);
+        value.pop_back();
+        arguments.push_back(std::move(value));
+    }
+    return run(arguments);
+}
+#else
+int main(int argc, char** argv) {
+    return run(std::vector<std::string>(argv, argv + argc));
+}
+#endif

package/src/local-ai/nemo-models.mjs

@@ -0,0 +1,160 @@
+import {randomUUID} from 'node:crypto';
+
+/** Selected native assets from NVIDIA NeMo-Speech.cpp v0.2.0 models/index.json. */
+export const NEMO_SPEECH_MODELS = {
+    stt: {
+        modelId: 'nemotron-3.5-asr-streaming-0.6b',
+        providerId: 'nemotron',
+        name: 'Nemotron 3.5 + speaker diarization',
+        members: [
+            {
+                path: 'nemotron-3.5-asr-streaming-0.6b.q8_0.gguf',
+                url: 'https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-0.6b/resolve/1c8deaecc64b91f034d73e08dd8b64625eb3395d/nemotron-3.5-asr-streaming-0.6b.q8_0.gguf'
+            },
+            {
+                path: 'Nemotron-3-Diarization.q8_0.gguf',
+                url: 'https://huggingface.co/nvidia/Nemotron-3-Diarization/resolve/f667ed73aee57d40cc39428eb768b4fd87a0a29e/Nemotron-3-Diarization.q8_0.gguf'
+            }
+        ],
+        resourcePaths: {
+            model: 'nemotron-3.5-asr-streaming-0.6b.q8_0.gguf',
+            diarization: 'Nemotron-3-Diarization.q8_0.gguf'
+        }
+    },
+    tts: {
+        modelId: 'magpie',
+        providerId: 'magpie-native',
+        name: 'Magpie + NanoCodec',
+        members: [
+            {
+                path: 'magpie_tts_multilingual_357m.v2607.f16.gguf',
+                url: 'https://huggingface.co/nvidia/magpie_tts_multilingual_357m/resolve/19806879b16d3f2ccf28fb112b1bcd16a3c7923e/magpie_tts_multilingual_357m.v2607.f16.gguf'
+            },
+            {
+                path: 'nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf',
+                url: 'https://huggingface.co/nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps/resolve/fc00890b604aa2de298d2641ffc6c5f6caf8c4d7/nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf'
+            }
+        ],
+        archives: [
+            {
+                url: 'https://huggingface.co/nvidia/magpie_tts_multilingual_357m/resolve/19806879b16d3f2ccf28fb112b1bcd16a3c7923e/magpie_tts_multilingual_357m.nemo',
+                format: 'tar',
+                // These offsets select upstream TAR segments at the transport
+                // boundary. Their complete selected members stay unchanged.
+                ranges: [
+                    {start: 0, end: 20619263, stopBefore: 'model_weights.ckpt'},
+                    {start: 1459750400, end: 1470207999}
+                ],
+                members: [
+                    {
+                        path: 'tokenizer/05adc40366e149b69319acd4b28a4919_pt_br_prondict-v1.0.dict',
+                        member: '05adc40366e149b69319acd4b28a4919_pt_br_prondict-v1.0.dict'
+                    },
+                    {
+                        path: 'tokenizer/339da71c54b046f98cbcf38ef6d4ff67_hindi_phoneme_merged_phoneme_dict.dict',
+                        member: '339da71c54b046f98cbcf38ef6d4ff67_hindi_phoneme_merged_phoneme_dict.dict'
+                    },
+                    {
+                        path: 'tokenizer/41913ebaa70342058574da74293b7630_magpie_tts_multilingual_357m.nemo.speakers.json',
+                        member: '41913ebaa70342058574da74293b7630_magpie_tts_multilingual_357m.nemo.speakers.json'
+                    },
+                    {
+                        path: 'tokenizer/61d57a4ccb064d1e8e3d9f871c571932_heteronyms-052722',
+                        member: '61d57a4ccb064d1e8e3d9f871c571932_heteronyms-052722'
+                    },
+                    {
+                        path: 'tokenizer/74b3e832fe914a569fcd42b51d06b2f1_ipa_dict_nv23.05.txt',
+                        member: '74b3e832fe914a569fcd42b51d06b2f1_ipa_dict_nv23.05.txt'
+                    },
+                    {
+                        path: 'tokenizer/7dbc31751f224f2486090d59dc95b9f7_es_ES_nv230301.dict',
+                        member: '7dbc31751f224f2486090d59dc95b9f7_es_ES_nv230301.dict'
+                    },
+                    {
+                        path: 'tokenizer/c5e4ec2af5a14ce294f4b9edcc936535_de_nv230119.heteronym',
+                        member: 'c5e4ec2af5a14ce294f4b9edcc936535_de_nv230119.heteronym'
+                    },
+                    {
+                        path: 'tokenizer/cf01ab5c48c84f3282ef7888263361e5_de_nv230119.dict',
+                        member: 'cf01ab5c48c84f3282ef7888263361e5_de_nv230119.dict'
+                    },
+                    {
+                        path: 'tokenizer/dc7d60d6b15a4651b21c9ca2932b62c6_ipa_cmudict-0.7b_nv23.01.txt',
+                        member: 'dc7d60d6b15a4651b21c9ca2932b62c6_ipa_cmudict-0.7b_nv23.01.txt'
+                    },
+                    {path: 'tokenizer/model_config.yaml', member: 'model_config.yaml'}
+                ]
+            }
+        ],
+        resourcePaths: {
+            model: 'magpie_tts_multilingual_357m.v2607.f16.gguf',
+            codec: 'nemo_nano_codec_22khz_1.89kbps_21.5fps.decoder.f16.gguf',
+            tokenizerConfig: 'tokenizer/model_config.yaml'
+        }
+    }
+};
+
+/** Explicitly acquire the complete ASR and diarization selection. */
+export function prepareNemotronModels(options = {}) {
+    return prepareModels(NEMO_SPEECH_MODELS.stt, options);
+}
+
+/** Explicitly acquire Magpie, NanoCodec and the matching tokenizer members. */
+export function prepareMagpieModels(options = {}) {
+    return prepareModels(NEMO_SPEECH_MODELS.tts, options);
+}
+
+async function prepareModels(selection, {modelAssets, workingDirectory, directories, id = randomUUID(), signal, onProgress, refresh = false}) {
+    if (typeof modelAssets?.prepare !== 'function' || typeof modelAssets?.release !== 'function') {
+        throw new TypeError('Native speech preparation requires the existing model-assets service.');
+    }
+    signal?.throwIfAborted();
+    let projection;
+    if (directories !== undefined && !refresh) {
+        if (typeof modelAssets.discover !== 'function' || typeof modelAssets.openExisting !== 'function') {
+            throw new TypeError('Installed native speech discovery requires the model-assets discover and openExisting methods.');
+        }
+        const discovered = await modelAssets.discover({
+            directories, signal,
+            catalog: [{id: selection.modelId, members: selection.members, archives: selection.archives,
+                entryPath: selection.resourcePaths.model}]
+        });
+        signal?.throwIfAborted();
+        const existing = discovered.models.find(function completeSelection(model) {
+            return model.complete && model.catalogId === selection.modelId;
+        });
+        if (existing) {
+            await onProgress?.({phase: 'reuse', completed: 0, total: existing.members.length, unit: 'files'});
+            signal?.throwIfAborted();
+            projection = await modelAssets.openExisting({id, directory: existing.directory, members: existing.members, signal});
+        }
+    }
+    const reused = projection !== undefined;
+    projection ??= await modelAssets.prepare({
+        id, workingDirectory, members: selection.members,
+        archives: selection.archives, signal, onProgress, refresh
+    });
+    let released;
+    function release() {
+        released ??= Promise.resolve().then(function releasePreparation() { return modelAssets.release(projection.id); });
+        return released;
+    }
+    try {
+        signal?.throwIfAborted();
+        if (reused) {
+            await onProgress?.({phase: 'ready', completed: projection.members.length, total: projection.members.length, unit: 'files'});
+            signal?.throwIfAborted();
+        }
+        return {
+            assetProjectionId: projection.id, directory: projection.directory,
+            members: projection.members, resourcePaths: {...selection.resourcePaths}, release
+        };
+    } catch (error) {
+        try {
+            await release();
+        } catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], 'Native speech preparation and cleanup failed.', {cause: error});
+        }
+        throw error;
+    }
+}

package/src/local-ai/nemotron/build.mjs

@@ -0,0 +1,53 @@
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {mkdir} from 'node:fs/promises';
+import {runProcess} from '../../process.mjs';
+
+/** Build the first-party ASR helper against the caller's installed NeMo SDK. */
+export async function buildNemotronHelper({runtime, outputRoot, signal, onEvent} = {}) {
+    if (typeof runtime?.cmakeDirectory !== 'string' || typeof outputRoot !== 'string') {
+        throw new TypeError('Nemotron requires the selected runtime cmakeDirectory and helper outputRoot.');
+    }
+    const root = path.resolve(outputRoot);
+    const build = path.join(root, 'build');
+    const source = fileURLToPath(
+        new URL('./native/', import.meta.url)
+    );
+    await mkdir(
+        root,
+        {recursive: true}
+    );
+    const options = {signal, onEvent};
+    const configure = await runProcess(
+        'cmake',
+        [
+            '-S', source,
+            '-B', build,
+            `-DNeMoSpeech_DIR=${path.resolve(runtime.cmakeDirectory)}`,
+            `-DCMAKE_INSTALL_PREFIX=${root}`,
+            '-DCMAKE_BUILD_TYPE=Release'
+        ],
+        options
+    );
+    const compile = await runProcess(
+        'cmake',
+        ['--build', build, '--config', 'Release'],
+        options
+    );
+    const install = await runProcess(
+        'cmake',
+        ['--install', build, '--config', 'Release'],
+        options
+    );
+    const executable = path.join(root, 'bin', process.platform === 'win32' ? 'arcane-nemotron.exe' : 'arcane-nemotron');
+    return {
+        platform: process.platform,
+        architecture: process.arch,
+        root,
+        executable,
+        helperExecutable: executable,
+        diagnostics: {configure, compile, install}
+    };
+}
+
+export default buildNemotronHelper;