adapter_registry.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include "adapter_registry.h"
#include "gemma4_adapter.h"
#include "generic_adapter.h"
#include "nemotron3_adapter.h"
#include "qwen35_adapter.h"
#include "qwen36_adapter.h"
 
#include <entropic/types/logging.h>
 
#include <algorithm>
#include <array>
#include <functional>
#include <string_view>
 
namespace entropic {
 
namespace {
auto logger = entropic::log::get("inference.adapter.registry");
 
using AdapterFactory = std::function<std::unique_ptr<ChatAdapter>(
    const std::string&, const std::string&)>;
 
struct AdapterEntry {
    std::string_view key;
    AdapterFactory factory;
};
 
const std::array<AdapterEntry, 4>& adapter_table() {
    static const std::array<AdapterEntry, 4> table{{
        {"qwen35",    [](auto& t, auto& p) {
            return std::make_unique<Qwen35Adapter>(t, p); }},
        {"qwen36",    [](auto& t, auto& p) {
            return std::make_unique<Qwen36Adapter>(t, p); }},
        {"gemma4",    [](auto& t, auto& p) {
            return std::make_unique<Gemma4Adapter>(t, p); }},
        {"nemotron3", [](auto& t, auto& p) {
            return std::make_unique<Nemotron3Adapter>(t, p); }},
    }};
    return table;
}
 
std::string to_lower(const std::string& name) {
    std::string lower = name;
    std::transform(lower.begin(), lower.end(), lower.begin(),
                   [](unsigned char c) { return std::tolower(c); });
    return lower;
}
 
} // anonymous namespace
 
std::unique_ptr<ChatAdapter> create_adapter(
    const std::string& name,
    const std::string& tier_name,
    const std::string& identity_prompt)
{
    const std::string lower = to_lower(name);
    for (const auto& entry : adapter_table()) {
        if (lower == entry.key) {
            logger->info("Adapter created: type={}, tier={}",
                         entry.key, tier_name);
            return entry.factory(tier_name, identity_prompt);
        }
    }
    if (lower != "generic") {
        logger->warn("Unknown adapter '{}', falling back to generic", name);
    }
    logger->info("Adapter created: type=generic, tier={}", tier_name);
    return std::make_unique<GenericAdapter>(tier_name, identity_prompt);
}
 
} // namespace entropic