Add string json check

Author: atobiszei

src/llm/io_processing/qwen3coder/qwen3coder_tool_parser.cpp

@@ -127,7 +127,20 @@ static const ParametersTypeMap_t parseToolSchema(const std::string& functionName
     return result;
 }
 
-// helper function to escape \n, "
+static std::string escapeQuotes(const std::string& input) {
+    std::string output;
+    output.reserve(input.size());
+    for (char c : input) {
+        switch (c) {
+        case '"':
+            output += "\\\"";
+            break;
+        default:
+            output += c;
+        }
+    }
+    return output;
+}
 static std::string escapeString(const std::string& input) {
     std::string output;
     output.reserve(input.size());
@@ -136,9 +149,6 @@ static std::string escapeString(const std::string& input) {
         case '\n':
             output += "\\n";
             break;
-        case '"':
-            output += "\\\"";
-            break;
         default:
             output += c;
         }
@@ -153,7 +163,7 @@ static std::string setCorrectValueType(std::string& inputValue, const std::strin
         return inputValue;
     }
     if (paramIt->second == ParameterType::STRING) {
-        inputValue = "\"" + inputValue + "\"";
+        inputValue = "\"" + escapeQuotes(inputValue) + "\"";
         return inputValue;
     }
     if (paramIt->second == ParameterType::BOOLEAN) {
@@ -240,8 +250,8 @@ bool Qwen3CoderToolParserImpl::parseUntilStateChange(ToolCalls_t& toolCalls) {
             SPDLOG_DEBUG("Tool schema not found for tool: {}, leaving parameter: {} as string", this->currentFunction.name, this->currentParameterName);
         } else {
             // we don't want to escape entry/exit " for string parameters
-            auto escaped = escapeString(parameterValue);
-            parameterValue = setCorrectValueType(escaped, this->currentParameterName, paramIt->second);
+            //            auto escaped = escapeString(parameterValue);
+            parameterValue = escapeString(setCorrectValueType(parameterValue, this->currentParameterName, paramIt->second));
         }
         auto res = this->currentFunction.parameters.try_emplace(this->currentParameterName, parameterValue);
         if (!res.second)
@@ -361,6 +371,7 @@ std::optional<rapidjson::Document> Qwen3CoderToolParser::sendFullDelta(std::opti
     // now we need to add string toolCall.arguments to argumentsWrapper under "arguments" key
     rapidjson::Value toolCallsString(rapidjson::kStringType);
     toolCallsString.SetString(toolCall.arguments.c_str(), allocator);
+    SPDLOG_TRACE("Tool call arguments string: {}", toolCall.arguments);
     argumentsWrapper.AddMember("arguments", toolCallsString, allocator);
     auto currentDelta = wrapDelta(argumentsWrapper, this->toolCallIndex);
     SPDLOG_DEBUG("First delta doc: {}", documentToString(currentDelta));

src/test/llm/output_parsers/qwen3coder_output_parser_test.cpp

@@ -691,6 +691,28 @@ if __name__ == "__main__":
                 SPDLOG_ERROR("Expected:\n{}", expected);
                 SPDLOG_ERROR("Got:\n{}", docStr);
                 EXPECT_EQ(docStr, expected) << "Mismatch for chunk: " << chunk;
+                // now we do final check
+                // we want to ensure that if we extract from expectedDelta["delta"]["tool_calls"][0]["function"]["arguments"] which as a string
+                // and then try to read this string as a json
+                if (expectedDelta.value().find("arguments") == std::string::npos) {
+                    SPDLOG_TRACE("No arguments to check for delta:\n{}", expectedDelta.value());
+                    continue;  // no arguments to check
+                }
+                auto docJsonIt = doc->FindMember("delta");
+                ASSERT_NE(docJsonIt, doc->MemberEnd());
+                auto toolCallsIt = docJsonIt->value.FindMember("tool_calls");
+                ASSERT_NE(toolCallsIt, docJsonIt->value.MemberEnd());
+                for (auto& toolCall : toolCallsIt->value.GetArray()) {
+                    auto functionIt = toolCall.FindMember("function");
+                    ASSERT_NE(functionIt, toolCall.MemberEnd());
+                    auto argumentsIt = functionIt->value.FindMember("arguments");
+                    ASSERT_NE(argumentsIt, functionIt->value.MemberEnd());
+                    const std::string& argumentsStr = argumentsIt->value.GetString();
+                    rapidjson::Document argsDoc;
+                    argsDoc.Parse(argumentsStr.c_str());  // now check for errors
+                    EXPECT_FALSE(argsDoc.HasParseError()) << "Arguments is not valid JSON for chunk: " << chunk << "\nArguments string:\n"
+                                                          << argumentsStr;
+                }
             }
         } else {
             EXPECT_TRUE(false) << "Mismatch between expectedDelta and doc for id: " << i << " chunk:\n"