Felipe97/llama-cpp-compiled

1#include "parsers.h"2 3common_chat_params common_chat_params_init_qwen3_coder(const common_chat_template &          tmpl,4                                                              const autoparser::generation_params & inputs) {5    common_chat_params data;6 7    const std::string GEN_PREFIX = "<|im_start|>assistant\n";8 9    data.prompt            = common_chat_template_direct_apply_impl(tmpl, inputs);10    data.generation_prompt = common_chat_template_generation_prompt_impl(tmpl, inputs);11    data.format            = COMMON_CHAT_FORMAT_PEG_NATIVE;12 13    auto supports_reasoning = tmpl.source().find("<think>") != std::string::npos;14 15    data.supports_thinking = supports_reasoning;16    data.preserved_tokens  = {17        "<tool_call>",18        "</tool_call>",19    };20 21    auto is_qwen3_coder  = !supports_reasoning;22 23    if (supports_reasoning) {24        data.thinking_start_tag = "<think>";25        // Support both </think> and <tool_call> as reasoning end sequences.26        // The newline variant comes first so it is included in the forced message27        // <function= is omitted, as it is a workaround for Qwen3-Coder which is not a thinking model28        data.thinking_end_tags = { "\n</think>", "</think>", "<tool_call>" };29        data.preserved_tokens.insert(data.preserved_tokens.end(), { "<think>", "</think>" });30    }31 32    data.message_delimiters = {33        { COMMON_CHAT_ROLE_ASSISTANT, "<|im_start|>assistant"             },34        { COMMON_CHAT_ROLE_TOOL,      "<|im_start|>user\n<tool_response>" }, // Qwen3-Coder, Qwen3.5, Nemotron Nano 335        { COMMON_CHAT_ROLE_TOOL,      "<|im_start|>tool_response"         }, // StepFun-3.5-Flash36        { COMMON_CHAT_ROLE_USER,      "<|im_start|>user"                  },37        { COMMON_CHAT_ROLE_SYSTEM,    "<|im_start|>system"                },38    };39 40    auto has_tools           = inputs.tools.is_array() && !inputs.tools.empty();41    auto has_response_format = inputs.json_schema.is_object() && !inputs.json_schema.empty();42    auto extract_reasoning   = inputs.reasoning_format != COMMON_REASONING_FORMAT_NONE;43    auto include_grammar     = has_response_format || (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE);44 45    if (inputs.has_continuation()) {46        const auto & msg = inputs.continue_msg;47 48        data.generation_prompt = GEN_PREFIX;49        if (supports_reasoning) {50            data.generation_prompt += "<think>\n" + msg.reasoning_content;51            if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_CONTENT) {52                data.generation_prompt += "\n</think>\n\n";53            }54        }55        if (inputs.continue_final_message == COMMON_CHAT_CONTINUATION_CONTENT) {56            data.generation_prompt += msg.render_content();57        }58 59        data.prompt += data.generation_prompt;60    }61 62    std::vector<std::string> tool_call_starts = { "<tool_call>" };63 64    if (is_qwen3_coder) {65        // Match complete <function=name> opener for Qwen3-Coder models that occasionally omit the66        // starting <tool_call>. The model may hallucinate a tool name, but it is preferable over67        // constraining on <function which may occur in valid content generation, e.g. #include <functional>68        foreach_function(inputs.tools, [&](const json & tool) {69            const std::string name = tool.at("function").at("name");70            tool_call_starts.push_back("<function=" + name + ">");71        });72    }73 74    auto parser = build_chat_peg_parser([&](common_chat_peg_builder & p) {75        auto generation_prompt = p.literal(GEN_PREFIX);76 77        auto reasoning = p.eps();78        if (supports_reasoning && extract_reasoning) {79            reasoning = p.optional("<think>" + p.space() +80                                   p.reasoning(p.until_one_of({ "</think>", "<tool_call>" })) +81                                   (p.literal("</think>") | p.peek(p.literal("<tool_call>"))));82        }83 84        // Response format parser85        if (has_response_format) {86            return generation_prompt + (reasoning << p.content(p.schema(p.json(), "response-format", inputs.json_schema)));87        }88 89        // Tool call parser90        if (has_tools && inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_NONE) {91            auto arg_close  = p.tool_arg_close(p.literal("\n</parameter>\n"));92            auto arg_string = p.rule("xml-arg-string",93                p.ac(p.tool_arg_string_value(p.until("\n</parameter>\n")) + arg_close, "\n</parameter>\n"));94 95            auto tool_choice = p.choice();96            foreach_function(inputs.tools, [&](const json & tool) {97                const auto & function = tool.at("function");98                std::string  name     = function.at("name");99 100                std::vector<common_peg_parser> required_args;101                std::vector<common_peg_parser> optional_args;102 103                foreach_parameter(function, [&](const common_chat_schema_property & param, const common_chat_schema_document_ptr & doc) {104                    auto rule_name = "tool-" + name + "-arg-" + param.name;105 106                    auto arg_open = p.tool_arg_open("<parameter=" + p.tool_arg_name(p.literal(param.name)) + ">\n");107 108                    auto types = param.schema->value_types();109 110                    auto arg_value = p.eps();111                    if (!types.has(common_chat_schema::TYPE_STRING)) {112                        arg_value = p.tool_arg_json_value(p.schema(p.json(), rule_name + "-schema", doc, *param.schema)) + arg_close;113                    } else if (types.is_only(common_chat_schema::TYPE_STRING)) {114                        arg_value = arg_string;115                    } else {116                        // The string alternative accepts any text, so the grammar only keeps the raw string117                        // rule. The parser still tries the JSON alternatives first to type the value.118                        auto json_value = p.choice();119                        if (types.has(common_chat_schema::TYPE_OBJECT)) {120                            json_value |= p.json_object();121                        }122                        if (types.has(common_chat_schema::TYPE_ARRAY)) {123                            json_value |= p.json_array();124                        }125                        if (types.has(common_chat_schema::TYPE_NUMBER) || types.has(common_chat_schema::TYPE_INTEGER)) {126                            json_value |= p.json_number();127                        }128                        if (types.has(common_chat_schema::TYPE_BOOLEAN)) {129                            json_value |= p.json_bool();130                        }131                        if (types.has(common_chat_schema::TYPE_NULL)) {132                            json_value |= p.json_null();133                        }134                        arg_value = p.gbnf(p.atomic(p.tool_arg_json_value(json_value) + arg_close) | arg_string, "xml-arg-string");135                    }136 137                    auto arg_rule = p.rule(rule_name, p.tool_arg(arg_open + arg_value));138 139                    (param.required ? required_args : optional_args).push_back(arg_rule);140                });141 142                // Accept required arguments in any order, as Qwen does not always adhere to the143                // order provided.144                auto args = p.permute("tool-" + name + "-args", required_args);145                if (!optional_args.empty()) {146                    args = args + p.zero_or_more(p.choice(optional_args));147                }148 149                auto func = p.tool(p.tool_open("<function=" + p.tool_name(p.literal(name)) + ">\n") +150                                   p.tool_args(args) +151                                   p.tool_close(p.literal("</function>\n")));152 153                tool_choice |= p.rule("tool-" + name, func);154            });155 156            auto min_calls = inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_REQUIRED ? 1 : 0;157 158            auto tool_call_body = tool_choice + "</tool_call>" + p.space();159            auto tool_call      = p.rule("tool-call", "<tool_call>\n" + tool_call_body);160 161            // Qwen3-Coder models may occasionally omit the <tool_call> token.162            auto tool_call_first = is_qwen3_coder ?163                p.rule("tool-call-first", p.optional(p.literal("<tool_call>\n")) + tool_call_body) :164                tool_call;165 166            auto calls      = inputs.parallel_tool_calls ? tool_call_first + p.zero_or_more(tool_call) : tool_call_first;167            auto tool_calls = p.trigger_rule("tool-call-root", p.repeat(calls, min_calls, 1));168 169            return generation_prompt +170                   (reasoning << p.content(p.until_one_of(tool_call_starts)) << tool_calls);171        }172 173        // Content only parser174        return generation_prompt + (reasoning << p.content(p.rest()));175    });176 177    data.parser = parser.save();178 179    if (include_grammar) {180        data.grammar_lazy = has_tools && inputs.tool_choice == COMMON_CHAT_TOOL_CHOICE_AUTO;181 182        data.grammar = build_grammar([&](const common_grammar_builder & builder) {183            parser.build_grammar(builder, data.grammar_lazy);184        });185 186        if (data.grammar_lazy) {187            for (const auto & start : tool_call_starts) {188                data.grammar_triggers.push_back({ COMMON_GRAMMAR_TRIGGER_TYPE_WORD, start });189            }190        }191    }192 193    return data;194}195