nemotron3_adapter.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
#include "nemotron3_adapter.h"
 
#include <entropic/types/logging.h>
 
#include <nlohmann/json.hpp>
 
#include <regex>
#include <sstream>
 
namespace entropic {
 
namespace {
auto logger = entropic::log::get("inference.adapter.nemotron3");
 
constexpr const char* TOOL_RESULT_SUFFIX =
    "Continue. Batch multiple tool calls in one response when possible.";
 
std::string generate_uuid() {
    static std::atomic<uint64_t> counter{0};
    return "tc-" + std::to_string(counter.fetch_add(1, std::memory_order_relaxed));
}
 
} // anonymous namespace
 
// ── Tool call parsing ──────────────────────────────────────
 
ParseResult Nemotron3Adapter::parse_tool_calls(const std::string& content) const {
    ParseResult result;
 
    auto calls = parse_dsml_function_calls(content);
    if (calls.empty()) {
        calls = parse_xml_function_calls(content);
    }
    if (calls.empty()) {
        calls = parse_tagged_tool_calls(content);
    }
 
    result.tool_calls = std::move(calls);
    result.cleaned_content = clean_content(content);
    return result;
}
 
// ── DSML invoke parsing (gh#70, native Nemotron 3 format) ──
 
std::vector<ToolCall> Nemotron3Adapter::parse_dsml_function_calls(
    const std::string& content) const
{
    std::vector<ToolCall> calls;
    // Custom `re` delimiter: the pattern contains `)"` sequences (from
    // the `name="..."` capture) that would terminate a default R"(...)"
    // literal early.
    std::regex invoke_pattern(
        R"re(<｜DSML｜invoke name="([^"]+)">([\s\S]*?)</｜DSML｜invoke>)re");
 
    auto begin = std::sregex_iterator(content.begin(), content.end(), invoke_pattern);
    auto end = std::sregex_iterator();
 
    for (auto it = begin; it != end; ++it) {
        ToolCall tc;
        tc.id = generate_uuid();
        tc.name = (*it)[1].str();
        tc.arguments = extract_dsml_parameters((*it)[2].str());
        calls.push_back(std::move(tc));
 
        logger->info("Parsed DSML invoke: {}", calls.back().name);
    }
    return calls;
}
 
std::unordered_map<std::string, std::string> Nemotron3Adapter::extract_dsml_parameters(
    const std::string& invoke_body) const
{
    std::unordered_map<std::string, std::string> arguments;
    // Custom `re` delimiter — same `)"`-in-pattern reason as the
    // invoke regex above.
    std::regex param_pattern(
        R"re(<｜DSML｜parameter name="([^"]+)"\s+(?:string|int|bool|value)="([^"]*)"\s*/>)re");
 
    auto begin = std::sregex_iterator(invoke_body.begin(), invoke_body.end(), param_pattern);
    auto end = std::sregex_iterator();
 
    for (auto it = begin; it != end; ++it) {
        arguments[(*it)[1].str()] = (*it)[2].str();
    }
    return arguments;
}
 
std::vector<ToolCall> Nemotron3Adapter::parse_xml_function_calls(
    const std::string& content) const
{
    std::vector<ToolCall> calls;
    std::regex func_pattern(R"(<function=([^>]+)>([\s\S]*?)</function>)");
 
    auto begin = std::sregex_iterator(content.begin(), content.end(), func_pattern);
    auto end = std::sregex_iterator();
 
    for (auto it = begin; it != end; ++it) {
        std::string func_name = (*it)[1].str();
        std::string func_body = (*it)[2].str();
 
        auto ns = func_name.find_first_not_of(" \t");
        auto ne = func_name.find_last_not_of(" \t");
        if (ns != std::string::npos) {
            func_name = func_name.substr(ns, ne - ns + 1);
        }
 
        ToolCall tc;
        tc.id = generate_uuid();
        tc.name = func_name;
        tc.arguments = extract_xml_parameters(func_body);
        calls.push_back(std::move(tc));
 
        logger->info("Parsed XML tool call: {}", func_name);
    }
    return calls;
}
 
std::unordered_map<std::string, std::string> Nemotron3Adapter::extract_xml_parameters(
    const std::string& func_body) const
{
    std::string body = func_body;
    auto nested = body.find("<function=");
    if (nested != std::string::npos) {
        logger->warn("Truncating function body at nested <function= tag");
        body = body.substr(0, nested);
    }
 
    std::unordered_map<std::string, std::string> arguments;
    std::regex param_pattern(R"(<parameter=([^>]+)>([\s\S]*?)</parameter>)");
 
    auto begin = std::sregex_iterator(body.begin(), body.end(), param_pattern);
    auto end = std::sregex_iterator();
 
    for (auto it = begin; it != end; ++it) {
        std::string key = (*it)[1].str();
        std::string value = (*it)[2].str();
 
        auto ks = key.find_first_not_of(" \t\n\r");
        auto ke = key.find_last_not_of(" \t\n\r");
        if (ks != std::string::npos) key = key.substr(ks, ke - ks + 1);
 
        auto vs = value.find_first_not_of(" \t\n\r");
        auto ve = value.find_last_not_of(" \t\n\r");
        if (vs != std::string::npos) value = value.substr(vs, ve - vs + 1);
 
        if (key.empty() || value.empty()) {
            logger->warn("Skipping empty XML parameter: key='{}' value='{}'", key, value);
            continue;
        }
        arguments[key] = value;
    }
    return arguments;
}
 
// ── Tool result formatting ─────────────────────────────────
 
Message Nemotron3Adapter::format_tool_result(
    const ToolCall& /*tool_call*/,
    const std::string& result) const
{
    Message msg;
    msg.role = "user";
    msg.content = "<tool_response>\n" + result +
                  "\n</tool_response>\n\n" + TOOL_RESULT_SUFFIX;
    return msg;
}
 
// ── Tool definition formatting ─────────────────────────────
 
static nlohmann::json build_tool_defs(
    const std::vector<std::string>& tool_jsons)
{
    nlohmann::json tool_defs = nlohmann::json::array();
    for (const auto& json_str : tool_jsons) {
        try {
            auto j = nlohmann::json::parse(json_str);
            tool_defs.push_back({
                {"type", "function"},
                {"function", {
                    {"name", j.value("name", "unknown")},
                    {"description", j.value("description", "")},
                    {"parameters", j.value("inputSchema",
                        nlohmann::json::object())}
                }}
            });
        } catch (...) {
            continue;
        }
    }
    return tool_defs;
}
 
std::string Nemotron3Adapter::format_tools(
    const std::vector<std::string>& tool_jsons) const
{
    std::ostringstream out;
    out << "# Tools\n\n"
        << "You may call one or more functions to assist with the user query.\n"
        << "Put your final answer OUTSIDE of any tool calls.\n\n"
        << "Here are the available tools:\n"
        << "<tools>\n"
        << build_tool_defs(tool_jsons).dump(2) << "\n"
        << "</tools>\n\n"
        << "For each function call, emit a DSML invoke block:\n"
        << "<｜DSML｜function_calls>\n"
        << "<｜DSML｜invoke name=\"example.tool\">\n"
        << "<｜DSML｜parameter name=\"param_name\" string=\"value\"/>\n"
        << "</｜DSML｜invoke>\n"
        << "</｜DSML｜function_calls>";
    return out.str();
}
 
// ── Content cleaning ───────────────────────────────────────
 
std::string Nemotron3Adapter::clean_content(const std::string& content) const {
    std::string cleaned = std::regex_replace(content,
        std::regex(R"(<tool_call>\s*[\s\S]*?\s*</tool_call>)"), "");
    cleaned = std::regex_replace(cleaned,
        std::regex(R"(<function=[^>]+>[\s\S]*?</function>)"), "");
    cleaned = std::regex_replace(cleaned,
        std::regex(R"(<｜DSML｜function_calls>[\s\S]*?</｜DSML｜function_calls>)"), "");
    cleaned = std::regex_replace(cleaned,
        std::regex(R"(<｜DSML｜invoke[\s\S]*?</｜DSML｜invoke>)"), "");
    cleaned = std::regex_replace(cleaned,
        std::regex(R"(</?｜[^>]*>)"), "");
    cleaned = strip_think_blocks(cleaned);
    return cleaned;
}
 
} // namespace entropic