microtorch::chat Namespace Reference

Namespaces
namespace	detail

Classes
struct	Error
struct	Message
struct	ParsedReply
struct	Piece
struct	Resolution
struct	Template
struct	ToolCall

Typedefs
using	json = nlohmann::ordered_json

Functions
Template	v1 ()
Template	v2 ()
Template	legacy_word ()
Template	chatml (const std::string &name, bool qwen25)
Template	gemma3 ()
std::vector< Template >	registry ()
Template	get (const std::string &id)
template<class J >
std::vector< Message >	messages_from_json (const J &a)
std::vector< Message >	from_pairs (const std::vector< std::pair< std::string, std::string > > &turns, const std::string *user=nullptr, const std::string *system=nullptr)
size_t	check_structure (const std::vector< Message > &m, bool prompt, bool tools_ok=false)
bool	py_space (uint32_t c)
std::string	strip_py_ws (const std::string &s)
std::string	tool_json (const json &d)
std::vector< Piece >	render_pieces (const std::vector< Message > &m, const Template &t, bool generation_prompt, int thinking=-1, const std::vector< json > &tools={})
std::string	render (const std::vector< Message > &m, const Template &t, bool generation_prompt, int thinking=-1, const std::vector< json > &tools={})
std::vector< std::pair< size_t, size_t > >	exchanges (const std::vector< Message > &m)
template<class Decode >
ParsedReply	parse_reply (const std::vector< int > &ids, int call_id, Decode decode)
void	check_control_tokens (const Template &t, const std::vector< std::string > &tokens, const std::vector< int32_t > &types)
std::string	jinja (const Template &t)
std::string	modelfile (const std::string &gguf_name, const Template &t)
Resolution	resolve (const std::string &declared, const std::vector< std::string > &tokens, const std::string &model, const std::string &chat_template, const std::string &arch)

Variables
constexpr const char *	kSystemModeV1 = "fold"
constexpr const char *	kDefaultSftTurns = "all"
constexpr const char *	kGGUFKey = "paperkiln.chat_template"
constexpr const char *	kV1 = "paperkiln/1"
constexpr const char *	kLegacyWord = "paperkiln/legacy-word"
constexpr const char *	kV2 = "paperkiln/2"
const std::array< const char *, 4 >	kV1Specials = {"<unk>", "<|endoftext|>", "<|user|>", "<|assistant|>"}
const std::array< const char *, 8 >	kV2Control

Typedef Documentation

json

using microtorch::chat::json = typedef nlohmann::ordered_json

Definition at line 71 of file chat_template.h.

Function Documentation

chatml()

Template microtorch::chat::chatml ( const std::string &  name, bool  qwen25  )

inline

Definition at line 286 of file chat_template.h.

                                                           {
    Template t;
    t.name = name;
    t.version = 1;
    t.system_mode = "turn";
    t.system_open = "<|im_start|>system\n";
    t.system_close = "<|im_end|>\n";
    t.user_open = "<|im_start|>user\n";
    t.user_close = "<|im_end|>\n";
    t.assistant_open = "<|im_start|>assistant\n";
    t.assistant_close = "<|im_end|>\n";
    t.generation_prompt = "<|im_start|>assistant\n";
    t.stop_eos = {"<|im_end|>", "<|endoftext|>"};
    t.reserved = {"<|im_start|>", "<|im_end|>", "<|endoftext|>"};
    t.markers = {"<|im_start|>", "<|im_end|>"};
    if (qwen25) {
        t.has_default_system = true;
        t.default_system = "You are Qwen, created by Alibaba Cloud. You are a helpful assistant.";
        t.match = {"d5495a1e5db0611132a97e46a65dbb64a642a499421228b9c8b93229097fa9a4"};
        t.architectures = {"qwen2"};
    } else {
        t.past_assistant = "strip_think";
        t.has_nothink = true;
        t.generation_prompt_nothink = "<|im_start|>assistant\n<think>\n\n</think>\n\n";
        t.match = {"57f1fd00f0013a2be96aa79b857391f27e23df5b5f847072b524c897e24d0361"};
        t.architectures = {"qwen3"};
    }
    return t;
}

References j, microtorch::chat::Template::name, and name.

Referenced by registry().

check_control_tokens()

void microtorch::chat::check_control_tokens ( const Template &  t, const std::vector< std::string > &  tokens, const std::vector< int32_t > &  types  )

inline

Definition at line 720 of file chat_template.h.

                                                                  {
    if (!t.has_tool) return;
    for (const auto& r : t.reserved) {
        bool ok = false;
        for (size_t i = 0; i < tokens.size() && !ok; ++i)
            ok = tokens[i] == r && i < types.size() && types[i] == 3;
        if (!ok) throw Error("chat template " + t.id() + " needs '" + r + "' as a control token of the vocabulary");
    }
}

References check_control_tokens(), and j.

Referenced by check_control_tokens(), and ember::make_chat_setup().

check_structure()

size_t microtorch::chat::check_structure ( const std::vector< Message > &  m, bool  prompt, bool  tools_ok = false  )

inline

Definition at line 443 of file chat_template.h.

                                                                                               {
    if (m.empty()) throw Error("a conversation needs a non-empty messages list");
    for (const auto& x : m) {
        if (x.role == "tool" && !tools_ok) throw Error("role 'tool' is reserved: no template defines it yet");
        if (x.role != "system" && x.role != "user" && x.role != "assistant" && x.role != "tool")
            throw Error("unknown role '" + x.role + "'");
        if (x.has_tool_calls && (!tools_ok || x.role != "assistant"))
            throw Error("tool_calls belong on assistant messages of a template with tool turns");
        if (x.has_tool_call_id && x.role != "tool") throw Error("tool_call_id belongs on tool messages");
    }
    const size_t first = m[0].role == "system" ? 1 : 0;
    if (first == m.size()) throw Error("a system message needs a user message after it");
    std::string want = "user";
    size_t pending = 0, call = 0;  // results still owed to the last calls; the next call they answer
    const Message* caller = nullptr;
    for (size_t i = first; i < m.size(); ++i) {
        if (m[i].role == "system") throw Error("a system message is allowed only as the first message");
        if (m[i].role != want) {
            if (!tools_ok)
                throw Error("message " + std::to_string(i) + " is " + m[i].role + ", expected " + want +
                            " (user and assistant alternate from the user)");
            throw Error("message " + std::to_string(i) + " is " + m[i].role + ", expected " + want +
                        " (user, then assistant; an assistant message with k tool calls, then k tool messages, then "
                        "assistant)");
        }
        if (m[i].loss >= 0 && m[i].role != "assistant") throw Error("loss is a bool on assistant messages only");
        if (m[i].role == "user") {
            want = "assistant";
        } else if (m[i].role == "assistant") {
            pending = m[i].tool_calls.size();
            call = 0;
            caller = &m[i];
            want = pending ? "tool" : "user";
        } else {
            const ToolCall& c = caller->tool_calls[call++];
            --pending;
            // A call without an id counts as id null (IR_SPEC 8.1.6): a null tool_call_id answers only such a call.
            if (m[i].has_tool_call_id && m[i].tool_call_id_null && c.has_id)
                throw Error("tool_call_id null is not the call's id '" + c.id + "' (tool messages answer the calls in "
                            "order; null answers a call without an id)");
            if (m[i].has_tool_call_id && !m[i].tool_call_id_null && (!c.has_id || m[i].tool_call_id != c.id))
                throw Error("tool_call_id '" + m[i].tool_call_id + "' is not the call's id (tool messages answer the "
                            "calls in order)");
            want = pending ? "tool" : "assistant";
        }
    }
    const std::string& last = m.back().role;
    if (prompt && !(last == "user" || (last == "tool" && pending == 0)))
        throw Error(std::string("a prompt conversation ends on a user message") +
                    (tools_ok ? " or on the last tool message of a call" : ""));
    if (!prompt && last != "assistant") throw Error("a training conversation ends on an assistant message");
    return first;
}

References c, and j.

exchanges()

std::vector< std::pair< size_t, size_t > > microtorch::chat::exchanges ( const std::vector< Message > &  m )

inline

Definition at line 673 of file chat_template.h.

                                                                                 {
    std::vector<std::pair<size_t, size_t>> out;
    for (size_t i = 0; i < m.size(); ++i)
        if (m[i].role == "user") {
            if (!out.empty()) out.back().second = i;
            out.push_back({i, m.size()});
        }
    return out;
}

References exchanges(), j, and out.

Referenced by ember::build_general_prompt(), exchanges(), and main().

from_pairs()

std::vector< Message > microtorch::chat::from_pairs ( const std::vector< std::pair< std::string, std::string > > &  turns, const std::string *  user = nullptr, const std::string *  system = nullptr  )

inline

Definition at line 429 of file chat_template.h.

                                                                                                           {
    std::vector<Message> m;
    if (system) m.push_back({"system", *system});
    for (const auto& t : turns) {
        m.push_back({"user", t.first});
        m.push_back({"assistant", t.second});
    }
    if (user) m.push_back({"user", *user});
    return m;
}

References j.

Referenced by main(), and ember::ChatFormat::prompt().

gemma3()

Template microtorch::chat::gemma3 ( )

inline

Definition at line 316 of file chat_template.h.

                         {
    Template t;
    t.name = "gemma3";
    t.version = 1;
    t.bos = "<bos>";
    t.content = "trim";
    t.system_mode = "fold";
    t.system_join = "\n\n";
    t.user_open = "<start_of_turn>user\n";
    t.user_close = "<end_of_turn>\n";
    t.assistant_open = "<start_of_turn>model\n";
    t.assistant_close = "<end_of_turn>\n";
    t.generation_prompt = "<start_of_turn>model\n";
    t.stop_eos = {"<end_of_turn>", "<eos>"};
    t.reserved = {"<start_of_turn>", "<end_of_turn>", "<bos>", "<eos>"};
    t.markers = {"<start_of_turn>", "<end_of_turn>"};
    t.match = {"7de1c58e208eda46e9c7f86397df37ec49883aeece39fb961e0a6b24088dd3c4"};
    t.architectures = {"gemma3"};
    return t;
}

References j, and microtorch::chat::Template::name.

Referenced by registry().

get()

Template microtorch::chat::get ( const std::string &  id )

inline

Definition at line 341 of file chat_template.h.

                                         {
    std::string known;
    for (const auto& t : registry()) {
        if (t.id() == id) return t;
        known += (known.empty() ? "" : ", ") + t.id();
    }
    throw Error("no chat template '" + id + "' (known: " + known + ")");
}

References microtorch::chat::Template::id(), id, j, and registry().

jinja()

std::string microtorch::chat::jinja ( const Template &  t )

inline

Definition at line 817 of file chat_template.h.

                                          {
    using detail::jstr;
    detail::paperkiln_only(t, "jinja()");
    if (t.content != "raw" || t.past_assistant != "keep" || t.has_default_system)
        throw Error("jinja() covers raw content, kept replies and no default system");
    if (t.has_tool) return detail::jinja_tools(t);
    std::string j;
    if (!t.bos.empty()) j += "{{- " + jstr(t.bos) + " -}}";
    j += "{%- if messages and messages[0]['role'] == 'system' -%}"
         "{%- set sys = messages[0]['content'] -%}{%- set msgs = messages[1:] -%}"
         "{%- else -%}{%- set sys = none -%}{%- set msgs = messages -%}{%- endif -%}";
    if (t.system_mode == "none")
        j += "{%- if sys is not none -%}{{ raise_exception('this model\\'s template has no system role') }}"
             "{%- endif -%}";
    else if (t.system_mode == "turn")
        j += "{%- if sys is not none -%}{{- " + jstr(t.system_open) + " + sys + " + jstr(t.system_close) +
             " -}}{%- endif -%}";
    j += "{%- for m in msgs -%}"
         "{%- if (m['role'] == 'user') != (loop.index0 % 2 == 0) -%}"
         "{{ raise_exception('user and assistant messages alternate from the user') }}{%- endif -%}"
         "{%- if m['role'] == 'user' -%}{{- " + jstr(t.user_open) + " -}}";
    if (t.system_mode == "fold")
        j += "{%- if loop.first and sys is not none -%}{{- sys + " + jstr(t.system_join) + " -}}{%- endif -%}";
    j += "{{- m['content'] + " + jstr(t.user_close) + " -}}"
         "{%- else -%}{{- " + jstr(t.assistant_open) + " + m['content'] + " + jstr(t.assistant_close) + " -}}"
         "{%- endif -%}{%- endfor -%}"
         "{%- if add_generation_prompt -%}{{- " + jstr(t.generation_prompt) + " -}}{%- endif -%}";
    return j;
}

References j, and jinja().

Referenced by jinja().

legacy_word()

Template microtorch::chat::legacy_word ( )

inline

Definition at line 270 of file chat_template.h.

                              {
    Template t;
    t.name = "paperkiln";
    t.version = "legacy-word";
    t.system_mode = kSystemModeV1;
    t.system_join = "\n\n";
    t.user_open = "user: ";
    t.user_close = " ";
    t.assistant_open = "assistant: ";
    t.assistant_close = " ";
    t.generation_prompt = "assistant:";
    t.stop_turn = {"user:", "assistant:"};
    return t;
}

References j, kSystemModeV1, and microtorch::chat::Template::name.

Referenced by registry(), and resolve().

messages_from_json()

template<class J >

std::vector< Message > microtorch::chat::messages_from_json

(

const J &

a

)

Definition at line 371 of file chat_template.h.

                                                  {
    if (!a.is_array()) throw Error("a conversation needs a messages list");
    std::vector<Message> out;
    for (const auto& m : a) {
        if (!m.is_object() || !m.contains("content") || !m["content"].is_string())
            throw Error("every message needs a role and a string content");
        Message x;
        x.role = m.value("role", std::string());
        x.content = m["content"].template get<std::string>();
        if (m.contains("loss")) {
            if (!m["loss"].is_boolean()) throw Error("loss is a bool on assistant messages only");
            x.loss = m["loss"].template get<bool>() ? 1 : 0;
        }
        if (m.contains("tool_calls")) {
            x.has_tool_calls = true;
            const auto& tc = m["tool_calls"];
            if (!tc.is_null()) {
                if (!tc.is_array() || tc.empty()) throw Error("tool_calls is a non-empty list");
                for (const auto& c : tc) {
                    if (!c.is_object() || !c.contains("function") || !c["function"].is_object())
                        throw Error("a tool call is {id?, type?: function, function: {name, arguments}}");
                    if (c.contains("type") && !(c["type"].is_string() && c["type"].template get<std::string>() == "function"))
                        throw Error("tool call type is not implemented (function)");
                    const auto& f = c["function"];
                    ToolCall k;
                    if (!f.contains("name") || !f["name"].is_string())
                        throw Error("a tool call's name is a non-empty string without a newline");
                    k.name = f["name"].template get<std::string>();
                    if (k.name.empty() || k.name.find('\n') != std::string::npos)
                        throw Error("a tool call's name is a non-empty string without a newline");
                    if (f.contains("arguments")) {
                        if (!f["arguments"].is_string()) throw Error("a tool call's arguments are a string (rendered verbatim)");
                        k.arguments = f["arguments"].template get<std::string>();
                    }
                    if (c.contains("id")) {
                        if (!c["id"].is_string()) throw Error("a tool call's id is a string");
                        k.has_id = true;
                        k.id = c["id"].template get<std::string>();
                    }
                    x.tool_calls.push_back(std::move(k));
                }
            }
        }
        if (m.contains("tool_call_id")) {
            x.has_tool_call_id = true;
            if (m["tool_call_id"].is_null())
                x.tool_call_id_null = true;
            else if (!m["tool_call_id"].is_string())
                throw Error("tool_call_id is a string or null");
            else
                x.tool_call_id = m["tool_call_id"].template get<std::string>();
        }
        out.push_back(std::move(x));
    }
    return out;
}

References a, c, j, k, out, and microtorch::chat::Message::role.

Referenced by ember::detail::tool_turn_message().

modelfile()

std::string microtorch::chat::modelfile ( const std::string &  gguf_name, const Template &  t  )

inline

Definition at line 847 of file chat_template.h.

                                                                          {
    using detail::go;
    detail::paperkiln_only(t, "modelfile()");
    if (t.has_tool) return detail::modelfile_tools(gguf_name, t);
    // No action trims whitespace, so the record's text is emitted exactly; the fold goes to the first user
    // message (Ollama keeps a system message in .Messages as well as in .System), as in tools/chat_template.py.
    std::string msgs = "{{ $first := true }}{{ range .Messages }}{{ if eq .Role \"user\" }}" + go(t.user_open);
    if (t.system_mode == "fold") msgs += "{{ if and $first $.System }}{{ $.System }}" + go(t.system_join) + "{{ end }}";
    msgs += "{{ $first = false }}{{ .Content }}" + go(t.user_close) + "{{ else if eq .Role \"assistant\" }}" +
            go(t.assistant_open) + "{{ .Content }}" + go(t.assistant_close) + "{{ end }}{{ end }}" + go(t.generation_prompt);
    std::string head = go(t.bos);
    if (t.system_mode == "turn")
        head += "{{ if .System }}" + go(t.system_open) + "{{ .System }}" + go(t.system_close) + "{{ end }}";
    std::string s = "# Ollama Modelfile for " + gguf_name + ": chat template " + t.id() +
                    " (LOCAL_LLM_STACK.md section 3, point 3).\nFROM ./" + gguf_name + "\nTEMPLATE \"\"\"" + head +
                    msgs + "\"\"\"\n";
    std::vector<std::string> stops = t.stop_eos;
    stops.insert(stops.end(), t.stop_turn.begin(), t.stop_turn.end());
    for (const auto& x : stops) s += "PARAMETER stop " + json(x).dump() + "\n";
    return s;
}

References j, and modelfile().

Referenced by modelfile().

parse_reply()

template<class Decode >

ParsedReply microtorch::chat::parse_reply	(	const std::vector< int > &	ids,
		int	call_id,
		Decode	decode
	)

Definition at line 695 of file chat_template.h.

                                                                               {
    std::vector<std::vector<int>> parts(1);
    for (int x : ids) {
        if (x == call_id) parts.emplace_back();
        else parts.back().push_back(x);
    }
    ParsedReply r;
    r.content = decode(parts[0]);
    for (size_t k = 1; k < parts.size(); ++k) {
        const std::string text = decode(parts[k]);
        const size_t nl = text.find('\n');
        if (nl == std::string::npos || nl == 0) return ParsedReply{false, {}, {}};
        ToolCall c;
        c.has_id = true;
        c.id = "call_" + std::to_string(k - 1);
        c.name = text.substr(0, nl);
        c.arguments = text.substr(nl + 1);
        r.tool_calls.push_back(std::move(c));
    }
    r.parsed = true;
    return r;
}

References c, microtorch::chat::ParsedReply::content, microtorch::chat::ToolCall::has_id, j, k, parse_reply(), and text.

Referenced by parse_reply(), and ember::reply_of().

py_space()

bool microtorch::chat::py_space ( uint32_t  c )

inline

Definition at line 504 of file chat_template.h.

                                 {
    return (c >= 0x09 && c <= 0x0d) || (c >= 0x1c && c <= 0x20) || c == 0x85 || c == 0xa0 || c == 0x1680 ||
           (c >= 0x2000 && c <= 0x200a) || c == 0x2028 || c == 0x2029 || c == 0x202f || c == 0x205f ||
           c == 0x3000;
}

References c.

Referenced by strip_py_ws().

registry()

std::vector< Template > microtorch::chat::registry ( )

inline

Definition at line 337 of file chat_template.h.

                                      {
    return {v1(), v2(), legacy_word(), chatml("chatml-qwen2.5", true), chatml("chatml-qwen3", false), gemma3()};
}

References chatml(), gemma3(), legacy_word(), v1(), and v2().

Referenced by get(), and resolve().

render()

std::string microtorch::chat::render ( const std::vector< Message > &  m, const Template &  t, bool  generation_prompt, int  thinking = -1, const std::vector< json > &  tools = {}  )

inline

Definition at line 663 of file chat_template.h.

                                                         {}) {
    std::string s;
    for (const auto& p : render_pieces(m, t, generation_prompt, thinking, tools)) s += p.text;
    return s;
}

References render().

Referenced by ember::build_general_prompt(), main(), ember::ChatFormat::prompt(), and render().

render_pieces()

std::vector< Piece > microtorch::chat::render_pieces ( const std::vector< Message > &  m, const Template &  t, bool  generation_prompt, int  thinking = -1, const std::vector< json > &  tools = {}  )

inline

Definition at line 578 of file chat_template.h.

                                                                                          {}) {
    if (!tools.empty() && !t.has_tools) throw Error("this model's template has no tool definitions");
    const size_t first = check_structure(m, generation_prompt, t.has_tool);
    const bool trim = t.content == "trim";
    auto check_reserved = [&](const std::string& s) {
        for (const auto& r : t.reserved)
            if (!r.empty() && s.find(r) != std::string::npos)
                throw Error("content holds the template's reserved text '" + r + "'");
        return s;
    };
    auto body = [&](std::string s) {
        if (trim) s = strip_py_ws(s);
        check_reserved(s);
        return s;
    };
    std::vector<Piece> out;
    auto add = [&](const std::string& text, const std::string& role, const char* kind, int idx) {
        if (!text.empty()) out.push_back({text, role, kind, idx});
    };
    add(t.bos, "", "bos", -1);
    bool have_sys = first == 1;
    std::string sys = have_sys ? m[0].content : std::string();
    const int sys_idx = have_sys ? 0 : -1;
    if (!have_sys && t.has_default_system && !t.default_system.empty()) {
        have_sys = true;
        sys = t.default_system;
    }
    std::string defs;
    for (size_t k = 0; k < tools.size(); ++k) defs += (k ? t.tools_sep : "") + check_reserved(tool_json(tools[k]));
    if (!tools.empty()) {
        const std::string head = have_sys ? body(sys) : std::string();
        sys = (head.empty() ? std::string() : head + t.tools_join) + defs;
        have_sys = true;
    }
    bool fold = false;
    std::string fold_text;
    if (have_sys) {
        if (t.system_mode == "none") throw Error("this model's template has no system role");
        if (t.system_mode == "turn") {
            add(t.system_open, "system", "open", sys_idx);
            add(tools.empty() ? body(sys) : sys, "system", "content", sys_idx);
            add(t.system_close, "system", "close", sys_idx);
        } else {
            check_reserved(sys);
            fold = true;
            fold_text = sys + t.system_join;
        }
    }
    size_t last_user = first;
    for (size_t i = first; i < m.size(); ++i)
        if (m[i].role == "user") last_user = i;
    for (size_t i = first; i < m.size(); ++i) {
        const std::string& role = m[i].role;
        const bool user = role == "user", tool = role == "tool";
        std::string text = body(m[i].content);
        if (user && fold) {
            text = fold_text + text;
            fold = false;
        }
        if (role == "assistant" && t.past_assistant == "strip_think" && i < last_user) {
            const size_t p = text.rfind("</think>");
            if (p != std::string::npos) {
                text = text.substr(p + 8);
                text.erase(0, text.find_first_not_of('\n') == std::string::npos ? text.size()
                                                                                    : text.find_first_not_of('\n'));
            }
        }
        const int idx = static_cast<int>(i);
        add(user ? t.user_open : tool ? t.tool_open : t.assistant_open, role, "open", idx);
        add(text, role, "content", idx);
        for (const auto& c : m[i].tool_calls) {
            add(t.tool_call_open, role, "call_open", idx);
            add(check_reserved(c.name) + t.tool_call_join + check_reserved(c.arguments), role, "call", idx);
        }
        add(user ? t.user_close : tool ? t.tool_close : t.assistant_close, role, "close", idx);
    }
    if (generation_prompt)
        add(thinking == 0 && t.has_nothink ? t.generation_prompt_nothink : t.generation_prompt, "", "generation", -1);
    else if (t.past_assistant == "strip_think")
        throw Error("a strip_think template renders prompt conversations only (HF re-wraps the reasoning of "
                    "replies after the last user message; prompts never have one)");
    return out;
}

Referenced by ember::build_general_prompt().

resolve()

Resolution microtorch::chat::resolve ( const std::string &  declared, const std::vector< std::string > &  tokens, const std::string &  model, const std::string &  chat_template, const std::string &  arch  )

inline

Definition at line 928 of file chat_template.h.

                                                                                 {
    Resolution r;
    r.chat = true;
    if (!declared.empty()) {
        r.tmpl = Template::from_json(json::parse(declared));
        r.why = "declared";
        return r;
    }
    bool v1specials = tokens.size() >= 4;
    for (size_t i = 0; v1specials && i < 4; ++i) v1specials = tokens[i] == kV1Specials[i];
    if (v1specials) {
        r.tmpl = v1();
        r.why = "paperkiln specials at ids 0-3";
        return r;
    }
    if (model == "word") {
        r.tmpl = legacy_word();
        r.why = "word-level vocabulary";
        return r;
    }
    const auto reg = registry();
    if (!chat_template.empty()) {
        const std::string h = detail::sha256_hex(chat_template);
        for (const auto& t : reg)
            for (const auto& m : t.match)
                if (m == h) {
                    r.tmpl = t;
                    r.why = "tokenizer.chat_template sha256 " + h.substr(0, 12);
                    return r;
                }
    }
    for (const auto& t : reg) {
        if (t.markers.empty()) continue;
        bool arch_ok = false;
        for (const auto& a : t.architectures) arch_ok = arch_ok || a == arch;
        bool all = arch_ok;
        for (const auto& mk : t.markers) {
            bool found = false;
            for (const auto& tok : tokens) found = found || tok == mk;
            all = all && found;
        }
        if (all) {
            r.tmpl = t;
            r.why = "markers and architecture " + arch;
            return r;
        }
    }
    r.chat = false;
    r.why = "no declared template, no paperkiln specials, and no known tokenizer.chat_template or markers: raw "
            "completion only";
    return r;
}

References a, microtorch::chat::Resolution::chat, j, kV1Specials, legacy_word(), registry(), resolve(), tok, and v1().

Referenced by ember::make_chat_setup(), and resolve().

strip_py_ws()

std::string microtorch::chat::strip_py_ws ( const std::string &  s )

inline

Definition at line 510 of file chat_template.h.

                                                 {
    // Decode the code point starting at i; returns its length (0 when invalid).
    auto decode = [&](size_t i, uint32_t& c) -> size_t {
        const unsigned char b = static_cast<unsigned char>(s[i]);
        size_t n = b < 0x80 ? 1 : (b >> 5) == 0x6 ? 2 : (b >> 4) == 0xe ? 3 : (b >> 3) == 0x1e ? 4 : 0;
        if (n == 0 || i + n > s.size()) return 0;
        c = n == 1 ? b : b & (0xff >> (n + 1));
        for (size_t k = 1; k < n; ++k) {
            const unsigned char x = static_cast<unsigned char>(s[i + k]);
            if ((x >> 6) != 0x2) return 0;
            c = (c << 6) | (x & 0x3f);
        }
        return n;
    };
    size_t b = 0;
    while (b < s.size()) {
        uint32_t c = 0;
        const size_t n = decode(b, c);
        if (n == 0 || !py_space(c)) break;
        b += n;
    }
    size_t e = s.size();
    while (e > b) {
        size_t st = e - 1;  // back up to the lead byte of the last code point
        while (st > b && (static_cast<unsigned char>(s[st]) >> 6) == 0x2 && e - st < 4) --st;
        uint32_t c = 0;
        const size_t n = decode(st, c);
        if (n != e - st || !py_space(c)) break;
        e = st;
    }
    return s.substr(b, e - b);
}

References c, j, k, n, and py_space().

tool_json()

std::string microtorch::chat::tool_json ( const json &  d )

inline

Definition at line 570 of file chat_template.h.

                                          {
    if (!d.is_object()) throw Error("a tool definition is a JSON object");
    return detail::dump_py(d);
}

References microtorch::chat::detail::dump_py().

v1()

Template microtorch::chat::v1 ( )

inline

Definition at line 232 of file chat_template.h.

                     {
    Template t;
    t.name = "paperkiln";
    t.version = 1;
    t.system_mode = kSystemModeV1;
    t.system_join = "\n\n";
    t.user_open = "<|user|>";
    t.assistant_open = "<|assistant|>";
    t.assistant_close = "<|endoftext|>";
    t.generation_prompt = "<|assistant|>";
    t.stop_eos = {"<|endoftext|>"};
    t.stop_turn = {"<|user|>", "<|assistant|>"};
    t.reserved = {"<|endoftext|>", "<|user|>", "<|assistant|>"};
    return t;
}

References j, kSystemModeV1, and microtorch::chat::Template::name.

Referenced by registry(), resolve(), ember::ChatFormat::v1_markers(), and v2().

v2()

Template microtorch::chat::v2 ( )

inline

Definition at line 249 of file chat_template.h.

                     {
    Template t = v1();
    t.version = 2;
    t.system_mode = "turn";
    t.system_join.clear();
    t.system_open = "<|system|>";
    t.has_tool = true;
    t.tool_open = "<|tool|>";
    t.tool_call_open = "<|tool_call|>";
    t.tool_call_join = "\n";
    t.has_tools = true;
    t.tools_join = "\n\n";
    t.tools_sep = "\n";
    t.stop_turn = {"<|user|>", "<|assistant|>", "<|system|>", "<|tool|>"};
    for (const char* c : kV2Control) t.reserved.push_back(c);
    return t;
}

References c, j, kV2Control, and v1().

Referenced by registry().

Variable Documentation

kDefaultSftTurns

constexpr const char* microtorch::chat::kDefaultSftTurns = "all"

inlineconstexpr

Definition at line 74 of file chat_template.h.

kGGUFKey

constexpr const char* microtorch::chat::kGGUFKey = "paperkiln.chat_template"

inlineconstexpr

Definition at line 75 of file chat_template.h.

kLegacyWord

constexpr const char* microtorch::chat::kLegacyWord = "paperkiln/legacy-word"

inlineconstexpr

Definition at line 77 of file chat_template.h.

kSystemModeV1

constexpr const char* microtorch::chat::kSystemModeV1 = "fold"

inlineconstexpr

Definition at line 73 of file chat_template.h.

Referenced by legacy_word(), and v1().

kV1

constexpr const char* microtorch::chat::kV1 = "paperkiln/1"

inlineconstexpr

Definition at line 76 of file chat_template.h.

kV1Specials

const std::array<const char*, 4> microtorch::chat::kV1Specials = {"<unk>", "<|endoftext|>", "<|user|>", "<|assistant|>"}

inline

Definition at line 79 of file chat_template.h.

{"<unk>", "<|endoftext|>", "<|user|>", "<|assistant|>"};

Referenced by ember::has_chat_specials(), and resolve().

kV2

constexpr const char* microtorch::chat::kV2 = "paperkiln/2"

inlineconstexpr

Definition at line 78 of file chat_template.h.

kV2Control

const std::array<const char*, 8> microtorch::chat::kV2Control

inline

Initial value:

= {"<|system|>",  "<|tool_call|>", "<|tool|>",    "<|spare_3|>",
                                                      "<|spare_4|>", "<|spare_5|>",   "<|spare_6|>", "<|spare_7|>"}

Definition at line 82 of file chat_template.h.

                                                   {"<|system|>",  "<|tool_call|>", "<|tool|>",    "<|spare_3|>",
                                                      "<|spare_4|>", "<|spare_5|>",   "<|spare_6|>", "<|spare_7|>"};

Referenced by v2().