gpt-oss : add support for response_format

common/chat-parser.h

@@ -15,6 +15,11 @@ class common_chat_msg_partial_exception : public std::runtime_error {
     common_chat_msg_partial_exception(const std::string & message) : std::runtime_error(message) {}
 };
 
+class common_chat_msg_parse_exception : public std::runtime_error {
+  public:
+    common_chat_msg_parse_exception(const std::string & message) : std::runtime_error(message) {}
+};
+
 class common_chat_msg_parser {
     std::string input_;
     bool is_partial_;

common/chat.cpp

@@ -296,6 +296,7 @@ json common_chat_msgs_to_json_oaicompat(const std::vector<common_chat_msg> & msg
         }
         if (!msg.reasoning_content.empty()) {
             jmsg["reasoning_content"] = msg.reasoning_content;
+            jmsg["thinking"] = msg.reasoning_content; // gpt-oss
         }
         if (!msg.tool_name.empty()) {
             jmsg["name"] = msg.tool_name;
@@ -1338,17 +1339,240 @@ static common_chat_params common_chat_params_init_gpt_oss(const common_chat_temp
     data.prompt = prompt;
     data.format = COMMON_CHAT_FORMAT_GPT_OSS;
 
-    // TODO: support tool calls in GPT-OSS?
+    // These special tokens are required to parse properly, so we include them
+    // even if parse_tool_calls is false.
+    data.preserved_tokens = {
+        "<|channel|>",
+        "<|constrain|>",
+        "<|message|>",
+        "<|start|>",
+        "<|end|>",
+    };
+
+    if (!inputs.json_schema.is_null()) {
+        data.grammar_lazy = false;
+        data.grammar = build_grammar([&](const common_grammar_builder & builder) {
+            auto analysis = builder.add_rule("analysis",
+                "\"<|channel|>analysis<|message|>\" ( [^<] | \"<\" [^|] )* \"<|end|>\"");
+            auto constrain = builder.add_rule("constrain", "\"<|constrain|>\"? [a-zA-Z0-9_-]+");
+            auto final = builder.add_rule("final",
+                "\"<|channel|>final\" ( \" \" " + constrain + " )? \"<|message|>\" " +
+                builder.add_schema("response", inputs.json_schema)
+            );
+            builder.add_rule("root", analysis + "? \"<|start|>assistant\" " + final);
+        });
+    }
+
+    if (inputs.tools.is_array() && !inputs.tools.empty()) {
+        data.grammar_lazy = inputs.tool_choice != COMMON_CHAT_TOOL_CHOICE_REQUIRED;
+        data.grammar = build_grammar([&](const common_grammar_builder & builder) {
+            // tool calls can appear in commentary or analysis channels
+            auto channel = builder.add_rule("channel", "\"<|channel|>\" ( \"commentary\" | \"analysis\" )");
+
+            std::vector<std::string> tool_rules_recipient_in_role;
+            std::vector<std::string> tool_rules_recipient_in_channel;
+            foreach_function(inputs.tools, [&](const json & tool) {
+                const auto & function = tool.at("function");
+                std::string name = function.at("name");
+                auto parameters = function.at("parameters");
+                builder.resolve_refs(parameters);
+
+                tool_rules_recipient_in_role.push_back(
+                    builder.add_rule(name + "-call",
+                        "\"" + name + "\"" + channel + " \" <|constrain|>json\"? \"<|message|>\" " +
+                        builder.add_schema(name + "-args", parameters)
+                    )
+                );
+
+                tool_rules_recipient_in_channel.push_back(
+                    builder.add_rule(name + "-call",
+                        "\"" + name + "\"" + " \" <|constrain|>json\"? \"<|message|>\" " +
+                        builder.add_schema(name + "-args", parameters)
+                    )
+                );
+            });
+
+            auto recipient_in_role = builder.add_rule("recipient_in_role",
+                "\"<|start|>assistant\"? \" to=functions.\" ( " +
+                string_join(tool_rules_recipient_in_role, " | ") + " )"
+            );
+
+            auto recipient_in_channel = builder.add_rule("recipient_in_channel",
+                channel + " \" to=functions.\" ( " +
+                string_join(tool_rules_recipient_in_channel, " | ") + " )"
+            );
+
+            builder.add_rule("root", recipient_in_role + " | " + recipient_in_channel);
+
+            // Trigger on tool calls that appear in the commentary channel
+            data.grammar_triggers.push_back({
+                COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN,
+                "<\\|channel\\|>(commentary|analysis) to"
+            });
+
+            // Trigger tool calls that appear in the role section, either at the
+            // start or in the middle.
+            data.grammar_triggers.push_back({
+                COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN_FULL,
+                "^ to"
+            });
+
+            data.grammar_triggers.push_back({
+                COMMON_GRAMMAR_TRIGGER_TYPE_PATTERN,
+                "<\\|start\\|>assistant to"
+            });
+        });
+    }
 
     return data;
 }
 static void common_chat_parse_gpt_oss(common_chat_msg_parser & builder) {
-    // TODO @ngxson : this won't work with --special enabled, we should fix that
-    builder.try_parse_reasoning("<|channel|>analysis<|message|>", "<|start|>assistant<|channel|>final<|message|>");
-    if (!builder.syntax().parse_tool_calls) {
-        builder.add_content(builder.consume_rest());
-        return;
+    static const common_regex message_regex("<\\|message\\|>");
+    static const common_regex channel_regex("<\\|channel\\|>(final|analysis|commentary)");
+    static const common_regex tool_call_channel_regex("<\\|channel\\|>(commentary|analysis)");
+    static const common_regex start_regex("<\\|start\\|>assistant");
+    static const common_regex end_regex("<\\|end\\|>");
+    static const common_regex to_regex(" to=");
+    static const common_regex function_regex("functions\\.([^<\\s]+)");
+    static const common_regex constrain_regex(" <\\|constrain\\|>([a-zA-Z0-9_-]+)");
+    static const common_regex user_tool_call_regex("(?: <\\|constrain\\|>([a-zA-Z]+))?<\\|message\\|>");
+    static const common_regex builtin_tool_call_regex("(?:browser|python)[\\s\\S]*<\\|message\\|>");
+
+    // Save the channel start so we can roll back to delegate reasoning parsing to builder.
+    size_t channel_start_pos = 0;
+
+    auto consume_until_next = [&](size_t from = std::string::npos) {
+        if (auto res = builder.try_find_regex(start_regex, from, false)) {
+            auto begin = res->groups[0].begin;
+            builder.move_to(begin);
+            return res->prelude;
+        }
+        return builder.consume_rest();
+    };
+
+    auto try_consume_message = [&]() {
+        if (builder.try_consume_regex(message_regex)) {
+            if (!builder.try_find_regex(end_regex)) {
+                builder.add_content(builder.consume_rest());
+            }
+            return true;
+        }
+        return false;
+    };
+
+    auto tool_call = [&](bool recipient_in_role) {
+        if (auto res = builder.try_consume_regex(function_regex)) {
+            auto name = builder.str(res->groups[1]);
+
+            if (recipient_in_role) {
+                if (!builder.try_consume_regex(tool_call_channel_regex)) {
+                    throw common_chat_msg_parse_exception("expected <|channel|>(commentary|analysis), got: " + consume_until_next());
+                }
+            }
+
+            if (builder.try_consume_regex(user_tool_call_regex)) {
+                if (auto args = builder.try_consume_json_with_dumped_args({{}})) {
+                    if (builder.syntax().parse_tool_calls) {
+                        if (!builder.add_tool_call(name, "", args->value) || args->is_partial) {
+                            throw common_chat_msg_partial_exception("incomplete tool call");
+                        }
+                    } else {
+                        std::string args_as_string;
+                        if (args->value.is_object()) {
+                            args_as_string = args->value.dump();
+                        } else {
+                            args_as_string = args->value;
+                        }
+
+                        // simulate tool call in content
+                        builder.add_content("<tool_call>");
+                        builder.add_content("{\"name\": " + json(name).dump() + ", \"arguments\": ");
+                        builder.add_content(args_as_string);
+                        if (!args->is_partial) {
+                            builder.add_content("}");
+                            builder.add_content("</tool_call>");
+                        } else {
+                            throw common_chat_msg_partial_exception("incomplete tool call");
+                        }
+                    }
+                }
+            } else {
+                throw common_chat_msg_parse_exception("expected function args, got: " + consume_until_next());
+            }
+        } else if (builder.try_consume_regex(builtin_tool_call_regex)) {
+            builder.consume_rest();
+            LOG_ERR("builtin tool calls not implemented\n");
+        } else {
+            throw common_chat_msg_parse_exception("expected function name, got: " + consume_until_next());
+        }
+    };
+
+    auto commentary = [&]() {
+        if (builder.try_consume_regex(to_regex)) {
+            tool_call(false);
+        } else if (!try_consume_message()) {
+            throw common_chat_msg_parse_exception("expected: \" to=\" or <|message|>, got: " + consume_until_next());
+        }
+    };
+
+    auto analysis = [&]() {
+        if (builder.try_consume_regex(to_regex)) {
+            tool_call(false); // built-in tools can be called in the analysis channel
+        } else if (builder.try_consume_regex(message_regex)) {
+            builder.move_to(channel_start_pos);
+            if (builder.syntax().reasoning_format == COMMON_REASONING_FORMAT_NONE || builder.syntax().reasoning_in_content) {
+                builder.add_content(consume_until_next());
+            } else {
+                builder.try_parse_reasoning("<|channel|>analysis<|message|>", "<|end|>");
+            }
+        } else {
+            throw common_chat_msg_parse_exception("expected: <|message|>, got: " + consume_until_next());
+        }
+    };
+
+    auto channel = [&](const common_chat_msg_parser::find_regex_result & match) {
+        auto type = builder.str(match.groups[1]);
+        if (type == "analysis") {
+            analysis();
+        } else if (type == "commentary") {
+            commentary();
+        } else if (type == "final") {
+            builder.try_consume_regex(constrain_regex); // response formats may emit user-defined formats
+            if (!try_consume_message()) {
+                throw common_chat_msg_parse_exception("expected: <|message|>, got: " + consume_until_next());
+            }
+        } else {
+            throw common_chat_msg_parse_exception("expected one of: [analysis, commentary, final], got: " + consume_until_next());
+        }
+    };
+
+    auto message = [&]() {
+        if (auto res = builder.try_consume_regex(channel_regex)) {
+            channel_start_pos = res->groups[0].begin;
+            channel(*res);
+        } else if (builder.try_consume_regex(to_regex)) {
+            tool_call(true);
+        } else {
+            throw common_chat_msg_parse_exception("expected: <|channel|> or \" to\", got: " + consume_until_next());
+        }
+    };
+
+    try {
+        message();
+    } catch (const common_chat_msg_parse_exception & e) {
+        LOG_DBG("Parse error: %s\n", e.what());
     }
+
+    // Read in complete messages until done or partial exception raised
+    while (auto res = builder.try_consume_regex(start_regex)) {
+        try {
+            message();
+        } catch (const common_chat_msg_parse_exception & e) {
+            LOG_DBG("Parse error: %s\n", e.what());
+        }
+    }
+
+    builder.consume_rest();
 }
 
 static common_chat_params common_chat_params_init_firefunction_v2(const common_chat_template & tmpl, const struct templates_params & inputs) {
@@ -1960,7 +2184,7 @@ static common_chat_params common_chat_templates_apply_jinja(
     }
 
     // GPT-OSS
-    if (src.find("<|channel|>") != std::string::npos && params.json_schema.is_null()) {
+    if (src.find("<|channel|>") != std::string::npos) {
         return common_chat_params_init_gpt_oss(tmpl, params);
     }