Move everything into the parse function

Author: aldehir

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

@@ -1353,8 +1353,88 @@ static common_chat_params common_chat_params_init_gpt_oss(const common_chat_temp
     return data;
 }
 static void common_chat_parse_gpt_oss(common_chat_msg_parser & builder) {
-    harmony_msg_parser parser(builder);
-    parser.parse();
+    //harmony_msg_parser parser(builder);
+    //parser.parse();
+
+    static const common_regex end_regex("<\\|end\\|>");
+    static const common_regex to_regex(" to=");
+    static const common_regex channel_type_regexp("(final|analysis|commentary)");
+    static const common_regex tool_call_regex(
+        "functions\\.([a-zA-Z_][a-zA-Z0-9_]*)\\s?(?:<\\|constrain\\|>([a-zA-Z]+))?<\\|message\\|>"
+    );
+
+    auto user_function = [&]() {
+        if (auto res = builder.try_consume_regex(tool_call_regex)) {
+            auto name = builder.str(res->groups[1]);
+            auto args = builder.consume_rest();
+            builder.add_tool_call(name, "", args);
+        }
+    };
+
+    auto commentary = [&]() {
+        if (builder.try_consume_regex(to_regex)) {
+            user_function();
+        }
+
+        if (builder.try_consume_literal("<|message|>")) {
+            if (!builder.try_find_regex(end_regex)) {
+                builder.add_content(builder.consume_rest());
+            }
+        }
+    };
+
+    auto final = [&]() {
+        if (builder.try_consume_literal("<|message|>")) {
+            builder.add_content(builder.consume_rest());
+        }
+    };
+
+    auto analysis = [&]() {
+        if (builder.try_consume_literal("<|message|>")) {
+            if (auto res = builder.try_find_regex(end_regex, std::string::npos, false)) {
+                builder.add_reasoning_content(res->prelude);
+            } else {
+                builder.add_reasoning_content(builder.consume_rest());
+            }
+        }
+    };
+
+    auto channel = [&]() {
+        if (builder.try_consume_literal("<|channel|>")) {
+            if (auto res = builder.try_consume_regex(channel_type_regexp)) {
+                auto type = builder.str(res->groups[0]);
+                if (type == "analysis") {
+                    analysis();
+                } else if (type == "final") {
+                    final();
+                } else if (type == "commentary") {
+                    commentary();
+                }
+            }
+        }
+    };
+
+    auto start = [&]() {
+        if (builder.try_consume_literal("assistant")) {
+            channel();
+        }
+    };
+
+    try {
+        channel();
+    } catch (const common_chat_msg_parse_exception & e) {
+        LOG_ERR("Parse error: %s", e.what());
+    }
+
+    while (builder.try_find_literal("<|start|>")) {
+        try {
+            start();
+        } catch(const common_chat_msg_parse_exception & e) {
+            LOG_ERR("Parse error: %s, skipping to next valid token", e.what());
+        }
+    }
+
+    builder.add_content(builder.consume_rest());
 }
 
 static common_chat_params common_chat_params_init_firefunction_v2(const common_chat_template & tmpl, const struct templates_params & inputs) {