chat: fix Laguna thinking=off false reasoning and </assistant> in output

Two bugs in the Laguna autoparser workaround:

1. With reasoning.start="" (delimiter-style), the streaming PEG parser
   speculatively captures all generated content as reasoning while
   waiting for </think>. When thinking is disabled and </think> never
   arrives, the stream ends with everything misclassified as reasoning,
   causing [Start thinking] to display for ordinary responses.

   Fix: check ctx.inputs.enable_thinking in analyze_reasoning::build_parser
   for the empty-start case. When thinking is off, return p.eps() so the
   parser skips reasoning entirely and treats all output as content.

2. </assistant> (the Laguna EOT token) appears as raw text in streaming
   output because the stop-word erase logic runs only on antiprompt
   entries. preserved_tokens only controls special-token decode; it
   does not strip text from the stream.

   Fix: add an additional_stops field to autoparser, populate it from
   the Laguna workaround with "</assistant>", propagate it through
   generate_parser into common_chat_params::additional_stops (which the
   server already routes into antiprompt via the "stop" JSON key), and
   apply it to task.params.antiprompt in cli.cpp so the CLI path also
   benefits.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: linuxid10t

common/chat-auto-parser-generator.cpp

@@ -47,6 +47,8 @@ common_chat_params peg_generator::generate_parser(const common_chat_template &
     data.generation_prompt = common_chat_template_generation_prompt(tmpl, inputs);
     data.format            = COMMON_CHAT_FORMAT_PEG_NATIVE;
     data.preserved_tokens  = autoparser.preserved_tokens;
+    data.additional_stops.insert(data.additional_stops.end(),
+        autoparser.additional_stops.begin(), autoparser.additional_stops.end());
 
     std::string parser_generation_prompt = data.generation_prompt;
 
@@ -164,7 +166,12 @@ common_peg_parser analyze_reasoning::build_parser(parser_build_context & ctx) co
                 // Standard tag-based: optional(<think>reasoning</think>)
                 return p.optional(p.optspace(start) + p.reasoning(p.until(trim_whitespace(end))) + p.optspace(end));
             }
-            // Delimiter-style (empty start)
+            // Delimiter-style (empty start): reasoning begins immediately at generation start.
+            // Only applies when thinking is enabled; with thinking disabled the generated stream
+            // contains no reasoning at all, so return eps to avoid misclassifying plain content.
+            if (!ctx.inputs.enable_thinking) {
+                return p.eps();
+            }
             return p.optional(p.reasoning(p.until(trim_whitespace(end))) + p.optspace(end));
         }
     }

common/chat-auto-parser.h

@@ -388,6 +388,9 @@ struct autoparser {
     // Preserved tokens for tokenizer (union of all non-empty markers)
     std::vector<std::string> preserved_tokens;
 
+    // Extra stop sequences added to sampling antiprompt (strip from streaming output)
+    std::vector<std::string> additional_stops;
+
     autoparser() = default;
 
     // Find the starting marker for the user message and assistant message

common/chat-diff-analyzer.cpp

@@ -173,11 +173,21 @@ static std::vector<std::function<void(const common_chat_template & tmpl, autopar
               LOG_DBG(ANSI_ORANGE "[Patch: JSON name/parameters tool instruction]\n" ANSI_RESET);
           }
       },
-      // Laguna (poolside) - </assistant> is both the EOT token and the role-closing tag;
-      // auto-detection leaves content.end empty so it never lands in preserved_tokens.
+      // Laguna (poolside): <think> is prefilled in the generation prompt, so the model's
+      // generated output starts with thinking content directly (no <think> marker in stream).
+      // Auto-detection picks up <think> as reasoning.start from multi-turn history diffs,
+      // which breaks the live parser since <think> is never in the generated token stream.
+      // Fix: clear reasoning.start so the parser treats generation-start as reasoning-start
+      // when enable_thinking=true; analyze_reasoning::build_parser skips reasoning entirely
+      // when enable_thinking=false to avoid misclassifying plain content as reasoning.
+      // Also: </assistant> is the EOT token and role-closing tag — add it to additional_stops
+      // so it is erased from streaming output (both server API and CLI) before being sent.
       [](const common_chat_template & tmpl, autoparser & analysis) -> void {
           if (tmpl.src.find("laguna_glm_thinking_v5") != std::string::npos) {
-              analysis.preserved_tokens.push_back("</assistant>");
+              analysis.reasoning.start = "";
+              analysis.reasoning.end   = "</think>";
+              analysis.reasoning.mode  = reasoning_mode::TAG_BASED;
+              analysis.additional_stops.push_back("</assistant>");
               LOG_DBG(ANSI_ORANGE "[Patch: Laguna]\n" ANSI_RESET);
           }
       },

tools/cli/cli.cpp

@@ -122,6 +122,11 @@ struct cli_context {
                     common_tokenize(vocab, defaults.sampling.reasoning_budget_message + chat_params.thinking_end_tag, false, true);
             }
 
+            // Apply template-derived stop sequences (e.g. </assistant> for Laguna)
+            for (const auto & stop : chat_params.additional_stops) {
+                task.params.antiprompt.push_back(stop);
+            }
+
             rd.post_task({std::move(task)});
         }