fix(reasoning): arm the reasoning parser from the rendered prompt

bindings/golang/Cargo.toml

@@ -35,6 +35,9 @@ workspace = true
 [dependencies.tool-parser]
 workspace = true
 
+[dependencies.reasoning-parser]
+workspace = true
+
 [dependencies.smg-grpc-client]
 workspace = true
 

bindings/golang/internal/ffi/preprocessor.go

@@ -44,6 +44,7 @@ SglErrorCode sgl_preprocess_chat_request_with_tokenizer(
 
 SglErrorCode sgl_chat_requires_reasoning_with_tokenizer(
     const char* request_json,
+    const char* prompt_text,
     void* tokenizer_handle,
     int32_t* require_reasoning_out,
     char** error_out
@@ -223,10 +224,15 @@ func PreprocessChatRequestWithTokenizer(requestJSON string, tokenizerHandle *Tok
 }
 
 // ChatRequiresReasoningWithTokenizer returns whether the request should ask
-// SGLang to count reasoning tokens, using the tokenizer's thinking defaults.
-func ChatRequiresReasoningWithTokenizer(requestJSON string, tokenizerHandle *TokenizerHandle) (bool, error) {
+// SGLang to count reasoning tokens. promptText is the rendered prompt from
+// PreprocessChatRequestWithTokenizer: its tail says whether the completion
+// starts inside the model's reasoning block; the tokenizer's thinking
+// defaults decide only when the prompt carries no reasoning marker.
+func ChatRequiresReasoningWithTokenizer(requestJSON string, promptText string, tokenizerHandle *TokenizerHandle) (bool, error) {
 	requestJSONC := C.CString(requestJSON)
 	defer C.free(unsafe.Pointer(requestJSONC))
+	promptTextC := C.CString(promptText)
+	defer C.free(unsafe.Pointer(promptTextC))
 
 	if tokenizerHandle == nil || tokenizerHandle.handle == nil {
 		return false, fmt.Errorf("invalid tokenizer handle")
@@ -237,6 +243,7 @@ func ChatRequiresReasoningWithTokenizer(requestJSON string, tokenizerHandle *Tok
 
 	errorCode := C.sgl_chat_requires_reasoning_with_tokenizer(
 		requestJSONC,
+		promptTextC,
 		unsafe.Pointer(tokenizerHandle.handle),
 		&requireReasoningOut,
 		&errorOut,

bindings/golang/internal/grpc/client_grpc.go

@@ -132,7 +132,7 @@ func (c *GrpcClient) CreateChatCompletionStream(ctx context.Context, reqJSON str
 		model = "default"
 	}
 
-	requireReasoning, err := ffi.ChatRequiresReasoningWithTokenizer(reqJSON, c.tokenizerHandle)
+	requireReasoning, err := ffi.ChatRequiresReasoningWithTokenizer(reqJSON, preprocessed.PromptText, c.tokenizerHandle)
 	if err != nil {
 		return nil, fmt.Errorf("failed to determine require_reasoning: %w", err)
 	}

bindings/golang/src/client.rs

@@ -215,7 +215,8 @@ pub unsafe extern "C" fn sgl_client_chat_completion_stream(
 
     // Build GenerateRequest
     let request_id = format!("chatcmpl-{}", Uuid::now_v7());
-    let require_reasoning = chat_requires_reasoning(&chat_request, tokenizer.as_ref());
+    let require_reasoning =
+        chat_requires_reasoning(&chat_request, &processed_messages.text, tokenizer.as_ref());
     let proto_request = match client.build_generate_request_from_chat(
         request_id.clone(),
         &chat_request,

bindings/golang/src/policy.rs

@@ -644,7 +644,8 @@ pub unsafe extern "C" fn sgl_multi_client_chat_completion_stream(
 
     // Build GenerateRequest
     let request_id = format!("chatcmpl-{}", Uuid::now_v7());
-    let require_reasoning = chat_requires_reasoning(&chat_request, tokenizer.as_ref());
+    let require_reasoning =
+        chat_requires_reasoning(&chat_request, &processed_messages.text, tokenizer.as_ref());
     let proto_request = match client.build_generate_request_from_chat(
         request_id.clone(),
         &chat_request,

bindings/golang/src/preprocessor.rs

@@ -355,21 +355,29 @@ pub unsafe extern "C" fn sgl_preprocessed_request_free(
     }
 }
 
-/// Determine whether a chat request should ask SGLang to count reasoning tokens.
+/// Determine whether a chat request should ask SGLang to count reasoning
+/// tokens. `prompt_text` is the request's rendered prompt (from
+/// `sgl_preprocess_chat_request_with_tokenizer`): its tail says whether the
+/// completion starts inside the model's reasoning block.
 ///
 /// # Safety
-/// - `request_json` must be a valid null-terminated C string.
+/// - `request_json` and `prompt_text` must be valid null-terminated C strings.
 /// - `tokenizer_handle` must be a valid pointer returned by `sgl_tokenizer_create`.
 /// - `require_reasoning_out` must point to writable memory.
 /// - `error_out` may be null; if non-null, must point to writable memory.
 #[no_mangle]
 pub unsafe extern "C" fn sgl_chat_requires_reasoning_with_tokenizer(
     request_json: *const c_char,
+    prompt_text: *const c_char,
     tokenizer_handle: *mut TokenizerHandle,
     require_reasoning_out: *mut c_int,
     error_out: *mut *mut c_char,
 ) -> SglErrorCode {
-    if request_json.is_null() || tokenizer_handle.is_null() || require_reasoning_out.is_null() {
+    if request_json.is_null()
+        || prompt_text.is_null()
+        || tokenizer_handle.is_null()
+        || require_reasoning_out.is_null()
+    {
         set_error_message(error_out, "Invalid arguments: null pointer");
         return SglErrorCode::InvalidArgument;
     }
@@ -382,6 +390,14 @@ pub unsafe extern "C" fn sgl_chat_requires_reasoning_with_tokenizer(
         }
     };
 
+    let prompt = match CStr::from_ptr(prompt_text).to_str() {
+        Ok(s) => s,
+        Err(_) => {
+            set_error_message(error_out, "Invalid UTF-8 in prompt_text");
+            return SglErrorCode::InvalidArgument;
+        }
+    };
+
     let chat_request: ChatCompletionRequest = match serde_json::from_str(request_str) {
         Ok(req) => req,
         Err(e) => {
@@ -393,6 +409,7 @@ pub unsafe extern "C" fn sgl_chat_requires_reasoning_with_tokenizer(
     let handle_ref = &*tokenizer_handle;
     *require_reasoning_out = i32::from(chat_requires_reasoning(
         &chat_request,
+        prompt,
         handle_ref.tokenizer.as_ref(),
     ));
 

bindings/golang/src/runtime.rs

@@ -1,6 +1,7 @@
 //! Shared runtime and global resources for FFI
 
 use once_cell::sync::Lazy;
+use reasoning_parser::ParserFactory as ReasoningParserFactory;
 use tokio::runtime::Runtime;
 use tool_parser::ParserFactory;
 
@@ -14,3 +15,8 @@ pub static RUNTIME: Lazy<Runtime> =
 
 /// Global parser factory (initialized once)
 pub static PARSER_FACTORY: Lazy<ParserFactory> = Lazy::new(ParserFactory::new);
+
+/// Global reasoning parser factory: resolves the model's parser so the
+/// rendered prompt can be read for its reasoning markers.
+pub static REASONING_PARSER_FACTORY: Lazy<ReasoningParserFactory> =
+    Lazy::new(ReasoningParserFactory::new);

bindings/golang/src/utils.rs

@@ -2,7 +2,7 @@
 
 use llm_tokenizer::traits::Tokenizer;
 use openai_protocol::chat::ChatCompletionRequest;
-use smg::routers::grpc::utils::chat_reasoning_starts_in_prefill;
+use smg::routers::grpc::utils::chat_reasoning_prefill;
 use uuid::Uuid;
 
 /// Helper function to generate tool call ID (matches router implementation)
@@ -26,10 +26,18 @@ pub fn generate_tool_call_id(
 }
 
 /// Determine whether the SGLang gRPC request should ask the backend to count
-/// reasoning tokens for this chat request.
+/// reasoning tokens for this chat request, rendered as `prompt`.
 pub(crate) fn chat_requires_reasoning(
     request: &ChatCompletionRequest,
+    prompt: &str,
     tokenizer: &dyn Tokenizer,
 ) -> bool {
-    chat_reasoning_starts_in_prefill(request, tokenizer)
+    chat_reasoning_prefill(
+        request,
+        prompt,
+        &super::runtime::REASONING_PARSER_FACTORY,
+        None,
+        tokenizer,
+    )
+    .expects_reasoning
 }

crates/reasoning_parser/src/lib.rs

@@ -9,5 +9,6 @@ pub use parsers::{
     PassthroughParser, Qwen3Parser, QwenThinkingParser, Step3Parser,
 };
 pub use traits::{
-    ParseError, ParserConfig, ParserResult, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE,
+    ParseError, ParserConfig, ParserResult, PromptReasoning, ReasoningParser,
+    DEFAULT_MAX_BUFFER_SIZE,
 };

crates/reasoning_parser/src/parsers/base.rs

@@ -1,7 +1,7 @@
 // Base implementation of reasoning parser that handles common logic
 // for detecting and extracting reasoning blocks from text.
 
-use crate::traits::{ParseError, ParserConfig, ParserResult, ReasoningParser};
+use crate::traits::{ParseError, ParserConfig, ParserResult, PromptReasoning, ReasoningParser};
 
 /// Base reasoning parser implementation.
 ///
@@ -173,6 +173,14 @@ impl ReasoningParser for BaseReasoningParser {
     fn is_in_reasoning(&self) -> bool {
         self.in_reasoning
     }
+
+    fn prompt_reasoning(&self, prompt: &str) -> PromptReasoning {
+        PromptReasoning::from_markers(
+            prompt,
+            &self.config.think_start_token,
+            &self.config.think_end_token,
+        )
+    }
 }
 
 #[cfg(test)]
@@ -394,4 +402,56 @@ mod tests {
             _ => panic!("Expected BufferOverflow error"),
         }
     }
+
+    #[test]
+    fn prompt_reasoning_reads_the_last_marker() {
+        let parser = create_test_parser(false, true);
+        // GLM-5.3 / DeepSeek-V3.1 style: the generation prompt opens the block.
+        assert_eq!(
+            parser.prompt_reasoning("<|user|>hi<|assistant|><think>"),
+            PromptReasoning::Open
+        );
+        // Qwen3 / GLM-4.5 with thinking off: an empty block is prefilled.
+        assert_eq!(
+            parser.prompt_reasoning("<|im_start|>assistant\n<think>\n\n</think>\n\n"),
+            PromptReasoning::Closed
+        );
+        // MiniMax-style: only the closing marker is prefilled.
+        assert_eq!(
+            parser.prompt_reasoning("<|assistant|></think>"),
+            PromptReasoning::Closed
+        );
+        // Qwen3 with thinking on: the model opens the block itself.
+        assert_eq!(
+            parser.prompt_reasoning("<|im_start|>assistant\n"),
+            PromptReasoning::Absent
+        );
+        // Earlier turns do not count; only the tail does.
+        assert_eq!(
+            parser.prompt_reasoning("<think>old</think>answer<|user|>again<|assistant|><think>"),
+            PromptReasoning::Open
+        );
+        assert_eq!(
+            parser.prompt_reasoning("<think>partial reasoning</think>final answer"),
+            PromptReasoning::Closed
+        );
+    }
+
+    #[test]
+    fn prompt_reasoning_uses_the_configured_markers() {
+        let config = ParserConfig {
+            think_start_token: "<reasoning>".to_string(),
+            think_end_token: "</reasoning>".to_string(),
+            ..Default::default()
+        };
+        let parser = BaseReasoningParser::new(config);
+        assert_eq!(
+            parser.prompt_reasoning("prompt<reasoning>"),
+            PromptReasoning::Open
+        );
+        assert_eq!(
+            parser.prompt_reasoning("prompt<think>"),
+            PromptReasoning::Absent
+        );
+    }
 }

crates/reasoning_parser/src/parsers/cohere_cmd.rs

@@ -5,7 +5,10 @@
 
 use crate::{
     parsers::BaseReasoningParser,
-    traits::{ParseError, ParserConfig, ParserResult, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE},
+    traits::{
+        ParseError, ParserConfig, ParserResult, PromptReasoning, ReasoningParser,
+        DEFAULT_MAX_BUFFER_SIZE,
+    },
 };
 
 /// Cohere Command model reasoning parser.
@@ -74,6 +77,10 @@ impl ReasoningParser for CohereCmdParser {
     fn mark_think_start_stripped(&mut self) {
         self.base.mark_think_start_stripped();
     }
+
+    fn prompt_reasoning(&self, prompt: &str) -> PromptReasoning {
+        self.base.prompt_reasoning(prompt)
+    }
 }
 
 #[cfg(test)]

crates/reasoning_parser/src/parsers/deepseek_r1.rs

@@ -4,7 +4,10 @@
 
 use crate::{
     parsers::BaseReasoningParser,
-    traits::{ParseError, ParserConfig, ParserResult, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE},
+    traits::{
+        ParseError, ParserConfig, ParserResult, PromptReasoning, ReasoningParser,
+        DEFAULT_MAX_BUFFER_SIZE,
+    },
 };
 
 /// DeepSeek-R1 reasoning parser.
@@ -73,6 +76,10 @@ impl ReasoningParser for DeepSeekR1Parser {
     fn mark_think_start_stripped(&mut self) {
         self.base.mark_think_start_stripped();
     }
+
+    fn prompt_reasoning(&self, prompt: &str) -> PromptReasoning {
+        self.base.prompt_reasoning(prompt)
+    }
 }
 
 #[cfg(test)]

crates/reasoning_parser/src/parsers/deepseek_v41.rs

@@ -21,7 +21,9 @@
 //! whitespace trimming. Streaming holds back a buffer suffix that could still
 //! grow into a marker of the current state and emits everything before it.
 
-use crate::traits::{ParseError, ParserResult, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE};
+use crate::traits::{
+    ParseError, ParserResult, PromptReasoning, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE,
+};
 
 /// The spaced DSML tool-call block opener; inside reasoning it ends the
 /// reasoning block implicitly and is kept at the start of the normal text.
@@ -215,4 +217,8 @@ impl ReasoningParser for DeepSeekV41Parser {
     /// The prefill consumed `<think>`; nothing to record, because a `<think>`
     /// that still appears inside reasoning is absorbed by the state machine.
     fn mark_think_start_stripped(&mut self) {}
+
+    fn prompt_reasoning(&self, prompt: &str) -> PromptReasoning {
+        PromptReasoning::from_markers(prompt, THINK_START, THINK_END)
+    }
 }

crates/reasoning_parser/src/parsers/glm45.rs

@@ -2,7 +2,10 @@
 
 use crate::{
     parsers::BaseReasoningParser,
-    traits::{ParseError, ParserConfig, ParserResult, ReasoningParser, DEFAULT_MAX_BUFFER_SIZE},
+    traits::{
+        ParseError, ParserConfig, ParserResult, PromptReasoning, ReasoningParser,
+        DEFAULT_MAX_BUFFER_SIZE,
+    },
 };
 
 /// GLM45 reasoning parser.
@@ -71,6 +74,10 @@ impl ReasoningParser for Glm45Parser {
     fn mark_think_start_stripped(&mut self) {
         self.base.mark_think_start_stripped();
     }
+
+    fn prompt_reasoning(&self, prompt: &str) -> PromptReasoning {
+        self.base.prompt_reasoning(prompt)
+    }
 }
 
 #[cfg(test)]