Fix special character escaping in tool parsers (#3693)

mzegla · web-flow · commit c84f4d91b785 · 2025-10-16T16:35:47.000+02:00
Co-authored-by: Copilot &lt;175728472+Copilot@users.noreply.github.com&gt;
Co-authored-by: Adrian Tobiszewski &lt;adrian.tobiszewski@intel.com&gt;

This PR fixes special character escaping in tool parsers to properly handle complex arguments containing characters like quotes, newlines, tabs, and backslashes. The changes standardize escape handling across different model output parsers and improve JSON parsing robustness.
diff --git a/src/llm/apis/openai_completions.cpp b/src/llm/apis/openai_completions.cpp
@@ -134,6 +134,34 @@ static absl::Status downloadImage(const char* url, std::string& image, const int
     return absl::OkStatus();
 }
 
+absl::Status OpenAIChatCompletionsHandler::ensureArgumentsInToolCalls(Value& messageObj, bool& jsonChanged) {
+    auto& allocator = doc.GetAllocator();
+    auto toolCallsIt = messageObj.FindMember("tool_calls");
+    if (toolCallsIt != messageObj.MemberEnd() && toolCallsIt->value.IsArray()) {
+        const auto& toolCallsArray = toolCallsIt->value.GetArray();
+        for (rapidjson::SizeType j = 0; j < toolCallsArray.Size(); ++j) {
+            auto& toolCall = toolCallsArray[j];
+            if (!toolCall.IsObject()) {
+                return absl::InvalidArgumentError("Each tool_call must be an object");
+            }
+            auto functionIt = toolCall.FindMember("function");
+            if (functionIt == toolCall.MemberEnd() || !functionIt->value.IsObject()) {
+                return absl::InvalidArgumentError("Each tool_call must have a 'function' object");
+            }
+            const auto& functionObj = functionIt->value.GetObject();
+            if (functionObj.FindMember("arguments") == functionObj.MemberEnd()) {
+                // Add "arguments": "{}"
+                rapidjson::Value argumentsKey("arguments", allocator);
+                rapidjson::Value argumentsValue;
+                argumentsValue.SetString("{}", allocator);
+                functionIt->value.GetObject().AddMember(argumentsKey, argumentsValue, allocator);
+                jsonChanged = true;
+            }
+        }
+    }
+    return absl::OkStatus();
+}
+
 absl::Status OpenAIChatCompletionsHandler::parseMessages(std::optional<std::string> allowedLocalMediaPath) {
     auto it = doc.FindMember("messages");
     if (it == doc.MemberEnd())
@@ -264,10 +292,21 @@ absl::Status OpenAIChatCompletionsHandler::parseMessages(std::optional<std::stri
                 }
             }
         }
-        const auto& lastMessage = request.chatHistory.back();
+        auto& lastMessage = request.chatHistory.back();
         if (lastMessage.find("role") == lastMessage.end()) {
             return absl::InvalidArgumentError("Every message must have 'role' field");
         }
+        if (lastMessage.find("content") == lastMessage.end()) {
+            SPDLOG_LOGGER_DEBUG(llm_calculator_logger, "Message does not have content field which might be an issue for some chat templates. Adding empty content.");
+            lastMessage["content"] = "";
+            obj.AddMember("content", Value().SetString("", doc.GetAllocator()), doc.GetAllocator());
+            jsonChanged = true;
+        }
+        // If message has tool calls, make sure each tool call has "arguments" field
+        auto status = ensureArgumentsInToolCalls(obj, jsonChanged);
+        if (status != absl::OkStatus()) {
+            return status;
+        }
     }
     if (jsonChanged) {
         StringBuffer buffer;
diff --git a/src/llm/apis/openai_completions.hpp b/src/llm/apis/openai_completions.hpp
@@ -78,6 +78,7 @@ class OpenAIChatCompletionsHandler {
     absl::Status parseCommonPart(std::optional<uint32_t> maxTokensLimit, uint32_t bestOfLimit, std::optional<uint32_t> maxModelLength);
 
     ParsedOutput parseOutputIfNeeded(const std::vector<int64_t>& generatedIds);
+    absl::Status ensureArgumentsInToolCalls(Value& messageObj, bool& jsonChanged);
 
 public:
     OpenAIChatCompletionsHandler(Document& doc, Endpoint endpoint, std::chrono::time_point<std::chrono::system_clock> creationTime,
diff --git a/src/llm/io_processing/hermes3/tool_parser.cpp b/src/llm/io_processing/hermes3/tool_parser.cpp
@@ -28,6 +28,7 @@
 #include "../../../logging.hpp"
 #include "tool_parser.hpp"
 #include "../utils.hpp"
+#include "src/stringutils.hpp"
 
 namespace ovms {
 
@@ -293,10 +294,8 @@ std::optional<rapidjson::Document> Hermes3ToolParser::parseChunk(const std::stri
     */
 
     if (lastJson.HasMember("arguments")) {
-        // Escaping double quotes in the arguments string
-        for (size_t pos = 0; (pos = modifiedChunk.find("\"", pos)) != std::string::npos; pos += 2) {
-            modifiedChunk.insert(pos, "\\");
-        }
+        // Since inside a string, we need to escape characters like quotes, new lines, tabs, etc.
+        escapeSpecialCharacters(modifiedChunk);
 
         bool processingFirstArgumentsChunk = argumentsDelayWindow[0].empty();
         // Handle the case when we are starting to collect arguments.
diff --git a/src/llm/io_processing/llama3/tool_parser.cpp b/src/llm/io_processing/llama3/tool_parser.cpp
@@ -29,6 +29,7 @@
 #include "../../../logging.hpp"
 #include "tool_parser.hpp"
 #include "../utils.hpp"
+#include "src/stringutils.hpp"
 
 namespace ovms {
 void Llama3ToolParser::parse(ParsedOutput& parsedOutput, const std::vector<int64_t>& generatedTokens) {
@@ -158,10 +159,8 @@ std::optional<rapidjson::Document> Llama3ToolParser::parseChunk(const std::strin
     // JSON already contains 'parameters'/'arguments' (they cannot be null at this point). Apply modifications to the input chunk if needed to keep the format valid.
     if (jsonHasArgumentsOrParameters(lastJson)) {
         std::string modifiedChunk = chunk;
-        // Escaping all double quotes in the parameters/arguments string
-        for (size_t pos = 0; (pos = modifiedChunk.find("\"", pos)) != std::string::npos; pos += 2) {
-            modifiedChunk.insert(pos, "\\");
-        }
+        // Since inside a string, we need to escape characters like quotes, new lines, tabs, etc.
+        escapeSpecialCharacters(modifiedChunk);
 
         // Handle the case when we are starting to collect parameters/arguments.
         // Force parameters/arguments string type and fill first element of the delay array.
diff --git a/src/llm/io_processing/partial_json_builder.cpp b/src/llm/io_processing/partial_json_builder.cpp
@@ -202,7 +202,18 @@ Document PartialJsonBuilder::add(const std::string& chunk) {
                     }
                 }
             } else if (c == '\\') {
-                finishedWithEscapeCharacter = true;
+                // Count consecutive backslashes before current position
+                auto backslashIt = it;
+                // Start with 1 since we found one backslash already
+                int backslashCount = 1;
+                while (backslashIt != buffer.begin() && *(backslashIt - 1) == '\\') {
+                    --backslashIt;
+                    ++backslashCount;
+                }
+                if (backslashCount % 2 != 0) {
+                    // Odd number of backslashes finishing the buffer: current backslash is escaping the next character
+                    finishedWithEscapeCharacter = true;
+                }
             }
         }
     }
@@ -264,7 +275,7 @@ Document PartialJsonBuilder::add(const std::string& chunk) {
     }
     doc.Parse(closedInput.c_str());
     if (doc.HasParseError()) {
-        throw std::runtime_error("Invalid JSON. Content:\n" + closedInput);
+        throw std::runtime_error("Invalid JSON. Content with closure attempt:\n" + closedInput + "\nOriginal content:\n" + buffer);
     }
     return doc;
 }
diff --git a/src/llm/io_processing/phi4/tool_parser.cpp b/src/llm/io_processing/phi4/tool_parser.cpp
@@ -29,6 +29,7 @@
 #include "../../../logging.hpp"
 #include "tool_parser.hpp"
 #include "../utils.hpp"
+#include "src/stringutils.hpp"
 
 namespace ovms {
 
@@ -257,15 +258,10 @@ std::optional<rapidjson::Document> Phi4ToolParser::parseChunk(const std::string&
             return std::nullopt;
         }
     } else {  // internalState == PROCESSING_TOOL_CALL
-        // Remove any newlines to avoid breaking JSON format
-        modifiedChunk.erase(std::remove(modifiedChunk.begin(), modifiedChunk.end(), '\n'), modifiedChunk.end());
-
         // JSON already contains 'arguments' (they cannot be null at this point). Apply modifications to the input chunk if needed to keep the format valid.
         if (processingArguments) {
-            // Escaping double quotes in the arguments string
-            for (size_t pos = 0; (pos = modifiedChunk.find("\"", pos)) != std::string::npos; pos += 2) {
-                modifiedChunk.insert(pos, "\\");
-            }
+            // Since inside a string, we need to escape characters like quotes, new lines, tabs, etc.
+            escapeSpecialCharacters(modifiedChunk);
 
             // Keep track of opened/closed braces to identify the end of the tool call object.
             updateOpenBracesCount(modifiedChunk);
@@ -282,6 +278,9 @@ std::optional<rapidjson::Document> Phi4ToolParser::parseChunk(const std::string&
                 // If we balanced the braces, we are at the end of the tool call object
                 handleEndOfToolCall(modifiedChunk);
             }
+        } else {
+            // Remove any newlines to avoid breaking JSON format
+            modifiedChunk.erase(std::remove(modifiedChunk.begin(), modifiedChunk.end(), '\n'), modifiedChunk.end());
         }
 
         // Phase 2: Parse the modified chunk with PartialJsonBuilder and return appropriate delta if possible
diff --git a/src/stringutils.cpp b/src/stringutils.cpp
@@ -255,4 +255,37 @@ bool stringsOverlap(const std::string& lhs, const std::string& rhs) {
     return false;
 }
 
+void escapeSpecialCharacters(std::string& text) {
+    // Escape all double quotes, backslashes, and control characters in the text
+    std::string escaped;
+    for (char c : text) {
+        switch (c) {
+        case '\"':
+            escaped += "\\\"";
+            break;
+        case '\\':
+            escaped += "\\\\";
+            break;
+        case '\b':
+            escaped += "\\b";
+            break;
+        case '\f':
+            escaped += "\\f";
+            break;
+        case '\n':
+            escaped += "\\n";
+            break;
+        case '\r':
+            escaped += "\\r";
+            break;
+        case '\t':
+            escaped += "\\t";
+            break;
+        default:
+            escaped += c;
+        }
+    }
+    text = escaped;
+}
+
 }  // namespace ovms
diff --git a/src/stringutils.hpp b/src/stringutils.hpp
@@ -111,4 +111,6 @@ std::string toLower(const std::string& input);
 
 bool stringsOverlap(const std::string& lhs, const std::string& rhs);
 
+void escapeSpecialCharacters(std::string& text);
+
 }  // namespace ovms
diff --git a/src/test/llm/output_parsers/llama3_output_parser_test.cpp b/src/test/llm/output_parsers/llama3_output_parser_test.cpp
@@ -31,7 +31,7 @@ const std::string tokenizerPath = getWindowsRepoRootPath() + "\\src\\test\\llm_t
 const std::string tokenizerPath = "/ovms/src/test/llm_testing/meta-llama/Llama-3.1-8B-Instruct";
 #endif
 
-static const ovms::ToolsSchemas_t EMPTY_TOOL_SCHEMA = {};  // not used for llama3
+static const ovms::ToolsSchemas_t EMPTY_TOOLS_SCHEMA = {};  // not used for llama3
 static std::unique_ptr<ov::genai::Tokenizer> llama3Tokenizer;
 
 // Id of the <|python_tag|> which is a special token used to indicate the start of a tool calls
@@ -57,8 +57,8 @@ class Llama3OutputParserTest : public ::testing::Test {
     }
 
     void SetUp() override {
-        outputParserWithRegularToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOL_SCHEMA);
-        outputParserWithImmediateToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOL_SCHEMA);
+        outputParserWithRegularToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOLS_SCHEMA);
+        outputParserWithImmediateToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOLS_SCHEMA);
         outputParserWithImmediateToolParsing->enableImmediateToolParsing();
     }
 };
@@ -223,7 +223,7 @@ TEST_F(Llama3OutputParserTest, HolisticStreaming) {
 
     for (auto lastFinishReason : {ov::genai::GenerationFinishReason::NONE, ov::genai::GenerationFinishReason::STOP, ov::genai::GenerationFinishReason::LENGTH}) {
         // Need to have new output parser per case to simulate separate request processing
-        outputParserWithRegularToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOL_SCHEMA);
+        outputParserWithRegularToolParsing = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOLS_SCHEMA);
         auto chunkToDeltaVecCopy = chunkToDeltaVec;
         if (lastFinishReason == ov::genai::GenerationFinishReason::NONE) {
             chunkToDeltaVecCopy.push_back({"Paris\"}}", ov::genai::GenerationFinishReason::NONE, R"({"delta":{"tool_calls":[{"index":1,"function":{"arguments":" \""}}]}})"});
@@ -284,6 +284,126 @@ TEST_F(Llama3OutputParserTest, HolisticStreaming) {
     }
 }
 
+// Positive test for streaming tool calls with complex arguments containing special characters
+TEST_F(Llama3OutputParserTest, StreamingToolWithComplexArguments) {
+    std::vector<std::tuple<std::string, std::optional<std::string>>> chunkToDeltaVec{
+        {"{\"", std::nullopt},
+        {"name", std::nullopt},
+        {"\":", std::nullopt},
+        {" \"", std::nullopt},
+        {"python_code", std::nullopt},
+        {"_", std::nullopt},
+        {"execution_tool", std::nullopt},
+        {"\",", std::nullopt},
+        {" \"", std::nullopt},
+        {"arguments", std::nullopt},
+        // As we have 'arguments' key present, we can return first delta
+        {"\":", "{\"delta\":{\"tool_calls\":[{\"id\":\"XXXXXXXXX\",\"type\":\"function\",\"index\":0,\"function\":{\"name\":\"python_code_execution_tool\"}}]}}"},
+        // Consecutive deltas without 'id' and 'type'. In order to find the end of arguments parser has one chunk delay to handle end of tool.
+        {" {", std::nullopt},
+        {"\"", "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"{\"}}]}}"},
+        {"function", "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]}}"},
+        {"\": ", "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"function\"}}]}}"},
+        {"\"", "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \"}}]}}"},
+        /*
+        Next chunks will simulate sending piece of Python code as argument value.
+        ```python
+        def example_function(arg1, arg2):
+            nested_dict = {"nested_arg1": "nested_value1", "nested_arg2": "nested_value2"}
+            if arg1 == "value1" and arg2 == "arg2":
+                return nested_dict
+            else:
+                return {}
+        ```
+        */
+        {"def example_function(arg1, arg2):\n", "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]}}"},
+
+        {"\tnested_dict = {\"nested_arg1\": \"nested_value1\", \"nested_arg2\": \"nested_value2\"}\n",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"def example_function(arg1, arg2):\\n\"}}]}}"},
+        {"\tif arg1 == \"value1\" and arg2 == \"arg2\":\n",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\tnested_dict = {\\\"nested_arg1\\\": \\\"nested_value1\\\", \\\"nested_arg2\\\": \\\"nested_value2\\\"}\\n\"}}]}}"},
+        {"\t\treturn nested_dict\n",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\tif arg1 == \\\"value1\\\" and arg2 == \\\"arg2\\\":\\n\"}}]}}"},
+        {"\telse:\n",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\t\\treturn nested_dict\\n\"}}]}}"},
+        {"\t\treturn {}\n",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\telse:\\n\"}}]}}"},
+        {"nested_arg1",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\t\\treturn {}\\n\"}}]}}"},
+        {"\": ",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nested_arg1\"}}]}}"},
+        {"\"",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \"}}]}}"},
+        {"nested_value1",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]}}"},
+        {"\", ",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nested_value1\"}}]}}"},
+        {"\"",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\", \"}}]}}"},
+        {"nested_arg2",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]}}"},
+        {"\": ",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nested_arg2\"}}]}}"},
+        {"\"",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\": \"}}]}}"},
+        {"nested_value2",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"\\\"\"}}]}}"},
+        {"\"}}}",
+            "{\"delta\":{\"tool_calls\":[{\"index\":0,\"function\":{\"arguments\":\"nested_value2\"}}]}}"},
+    };
+
+    auto outputParser = std::make_unique<OutputParser>(*llama3Tokenizer, "llama3", "", EMPTY_TOOLS_SCHEMA);
+    for (const auto& [chunk, expectedDelta] : chunkToDeltaVec) {
+        std::optional<rapidjson::Document> doc = outputParser->parseChunk(chunk, true, ov::genai::GenerationFinishReason::NONE);
+        if (!expectedDelta.has_value() && !doc.has_value()) {
+            continue;  // Both are nullopt, OK
+        }
+        if (expectedDelta.has_value() && doc.has_value()) {
+            rapidjson::StringBuffer buffer;
+            rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+            doc->Accept(writer);
+            std::string docStr = buffer.GetString();
+            // If both strings contain "id":"...", compare id values by length and alphanumeric, else compare whole strings
+            std::string expected = expectedDelta.value();
+            std::string idKey = "\"id\":\"";
+            auto docIdPos = docStr.find(idKey);
+            auto expectedIdPos = expected.find(idKey);
+            if (docIdPos != std::string::npos && expectedIdPos != std::string::npos) {
+                auto docIdStart = docIdPos + idKey.size();
+                auto docIdEnd = docStr.find("\"", docIdStart);
+                auto expectedIdStart = expectedIdPos + idKey.size();
+                auto expectedIdEnd = expected.find("\"", expectedIdStart);
+                ASSERT_NE(docIdEnd, std::string::npos);
+                ASSERT_NE(expectedIdEnd, std::string::npos);
+                std::string docId = docStr.substr(docIdStart, docIdEnd - docIdStart);
+                std::string expectedId = expected.substr(expectedIdStart, expectedIdEnd - expectedIdStart);
+                EXPECT_EQ(docId.size(), expectedId.size()) << "ID length mismatch for chunk: " << chunk;
+                EXPECT_TRUE(std::all_of(docId.begin(), docId.end(), ::isalnum)) << "ID not alphanumeric for chunk: " << chunk;
+                // Compare everything except the id value
+                std::string docStrNoId = docStr;
+                std::string expectedNoId = expected;
+                docStrNoId.replace(docIdStart, docId.size(), std::string(docId.size(), '*'));
+                expectedNoId.replace(expectedIdStart, expectedId.size(), std::string(expectedId.size(), '*'));
+                EXPECT_EQ(docStrNoId, expectedNoId) << "Mismatch for chunk (ignoring id value): " << chunk;
+            } else {
+                EXPECT_EQ(docStr, expected) << "Mismatch for chunk: " << chunk << " Received: " << docStr << ", expected: " << expected;
+            }
+        } else {
+            std::string expectedStr = expectedDelta.has_value() ? expectedDelta.value() : "std::nullopt";
+            std::string docStr = doc.has_value() ? [&]() {
+                rapidjson::StringBuffer buffer;
+                rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
+                doc->Accept(writer);
+                return std::string(buffer.GetString());
+            }()
+                                                 : "std::nullopt";
+            FAIL() << "Mismatch between expectedDelta and doc for chunk: " << chunk
+                   << "\nexpectedDelta: " << expectedStr
+                   << "\ndoc: " << docStr;
+        }
+    }
+}
+
 TEST_F(Llama3OutputParserTest, ToolCallsWithoutToolsInTheRequestStreaming) {
     std::vector<std::pair<std::string, std::optional<std::string>>> chunkToDeltaVec{
         // Tool parser is available, but tools are not in the request so every chunk is just a regular content
diff --git a/src/test/llm/output_parsers/partial_json_builder_test.cpp b/src/test/llm/output_parsers/partial_json_builder_test.cpp
diff --git a/src/test/llm/output_parsers/phi4_output_parser_test.cpp b/src/test/llm/output_parsers/phi4_output_parser_test.cpp
diff --git a/src/test/llm/output_parsers/qwen3_output_parser_test.cpp b/src/test/llm/output_parsers/qwen3_output_parser_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -202,7 +202,18 @@ Document PartialJsonBuilder::add(const std::string& chunk) {`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`	`} else if (c == '\\') {`
`205`		`- finishedWithEscapeCharacter = true;`
	`205`	`+ // Count consecutive backslashes before current position`
	`206`	`+ auto backslashIt = it;`
	`207`	`+ // Start with 1 since we found one backslash already`
	`208`	`+ int backslashCount = 1;`
	`209`	`+ while (backslashIt != buffer.begin() && *(backslashIt - 1) == '\\') {`
	`210`	`+ --backslashIt;`
	`211`	`+ ++backslashCount;`
	`212`	`+ }`
	`213`	`+ if (backslashCount % 2 != 0) {`
	`214`	`+ // Odd number of backslashes finishing the buffer: current backslash is escaping the next character`
	`215`	`+ finishedWithEscapeCharacter = true;`
	`216`	`+ }`
`206`	`217`	`}`
`207`	`218`	`}`
`208`	`219`	`}`
`@@ -264,7 +275,7 @@ Document PartialJsonBuilder::add(const std::string& chunk) {`
`264`	`275`	`}`
`265`	`276`	`doc.Parse(closedInput.c_str());`
`266`	`277`	`if (doc.HasParseError()) {`
`267`		`- throw std::runtime_error("Invalid JSON. Content:\n" + closedInput);`
	`278`	`+ throw std::runtime_error("Invalid JSON. Content with closure attempt:\n" + closedInput + "\nOriginal content:\n" + buffer);`
`268`	`279`	`}`
`269`	`280`	`return doc;`
`270`	`281`	`}`