fix(openai): keep streamed reasoning out of text_content so reasoning-model agent loops don't terminate early; bump 4.2.5

complete_streaming merged each reasoning delta into BOTH reasoning_content_accum AND
text_content (via merge_stream_text). For a reasoning model (glm5.1/zhipu, DeepSeek-R1),
the chain-of-thought thus landed in the assistant message's text content. Consequences:
- response.text() returned the reasoning, so a pure 'thinking' turn (reasoning, no content,
  no tool call) looked like a finished answer -> the agent loop's complete_no_tool_response
  treated it as final (looks_incomplete(reasoning) is usually false) and TERMINATED instead
  of giving the model another turn to act. In the multi-agent diagnose this is why workers
  never reached generate_object -> '未返回结构化输出'.
- skip_content (= !text_content.is_empty()) tripped once reasoning arrived, dropping the
  model's real content.

Fix: reasoning accumulates ONLY into reasoning_content (4 sites: message/delta branches of
both streaming fns); text_content holds real content only. A reasoning-only turn now yields
empty text() so looks_incomplete('')==true keeps the loop going. Two streaming regression
tests (mock SSE) lock it. Upstream agent-loop half of the same cross-model reasoning bug as
4.2.4's generate_object extraction fix.

Author: claude

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "a3s-code-core"
-version = "4.2.4"
+version = "4.2.5"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"

core/Cargo.toml

@@ -731,15 +731,23 @@ impl OpenAiClient {
                                             // skip message.content to avoid sending duplicate full content
                                             let skip_content = !text_content.is_empty();
                                             if let Some(reasoning) = message.reasoning_content {
-                                                reasoning_content_accum.push_str(&reasoning);
+                                                // Reasoning is its OWN channel — accumulate into
+                                                // reasoning_content, NEVER text_content. Merging it into
+                                                // text_content made the assistant's `content` carry the
+                                                // chain-of-thought, so a reasoning-only turn looked like a
+                                                // finished text answer (response.text() non-empty) and the
+                                                // agent loop terminated before the model emitted its tool
+                                                // call → workers never reach generate_object → asset-diagnose
+                                                // "未返回结构化输出". It also tripped `skip_content`, dropping
+                                                // the model's real content.
                                                 if first_token_ms.is_none() {
                                                     first_token_ms = Some(
                                                         request_started_at.elapsed().as_millis()
                                                             as u64,
                                                     );
                                                 }
                                                 if let Some(delta) = Self::merge_stream_text(
-                                                    &mut text_content,
+                                                    &mut reasoning_content_accum,
                                                     &reasoning,
                                                 ) {
                                                     let _ = tx
@@ -782,16 +790,18 @@ impl OpenAiClient {
                                             }
                                         } else if let Some(delta) = choice.delta {
                                             if let Some(ref rc) = delta.reasoning_content {
-                                                reasoning_content_accum.push_str(rc);
+                                                // Reasoning stays in reasoning_content, never text_content
+                                                // (see the message-branch note above).
                                                 if first_token_ms.is_none() {
                                                     first_token_ms = Some(
                                                         request_started_at.elapsed().as_millis()
                                                             as u64,
                                                     );
                                                 }
-                                                if let Some(delta) =
-                                                    Self::merge_stream_text(&mut text_content, rc)
-                                                {
+                                                if let Some(delta) = Self::merge_stream_text(
+                                                    &mut reasoning_content_accum,
+                                                    rc,
+                                                ) {
                                                     let _ = tx
                                                         .send(StreamEvent::ReasoningDelta(delta))
                                                         .await;
@@ -904,14 +914,16 @@ impl OpenAiClient {
                             let skip_content = !text_content.is_empty();
                             if let Some(message) = choice.message {
                                 if let Some(reasoning) = message.reasoning_content {
-                                    reasoning_content_accum.push_str(&reasoning);
+                                    // Reasoning → reasoning_content only, never text_content
+                                    // (see the note in complete_streaming).
                                     if first_token_ms.is_none() {
                                         first_token_ms =
                                             Some(request_started_at.elapsed().as_millis() as u64);
                                     }
-                                    if let Some(delta) =
-                                        Self::merge_stream_text(&mut text_content, &reasoning)
-                                    {
+                                    if let Some(delta) = Self::merge_stream_text(
+                                        &mut reasoning_content_accum,
+                                        &reasoning,
+                                    ) {
                                         let _ = tx.send(StreamEvent::ReasoningDelta(delta)).await;
                                     }
                                 }
@@ -941,13 +953,14 @@ impl OpenAiClient {
                                 }
                             } else if let Some(delta) = choice.delta {
                                 if let Some(ref rc) = delta.reasoning_content {
-                                    reasoning_content_accum.push_str(rc);
+                                    // Reasoning → reasoning_content only, never text_content
+                                    // (see the note in complete_streaming).
                                     if first_token_ms.is_none() {
                                         first_token_ms =
                                             Some(request_started_at.elapsed().as_millis() as u64);
                                     }
                                     if let Some(delta) =
-                                        Self::merge_stream_text(&mut text_content, rc)
+                                        Self::merge_stream_text(&mut reasoning_content_accum, rc)
                                     {
                                         let _ = tx.send(StreamEvent::ReasoningDelta(delta)).await;
                                     }
@@ -1200,6 +1213,115 @@ mod tests {
         OpenAiClient::new("test-key".to_string(), "gpt-test".to_string())
     }
 
+    // --- streaming reasoning-channel regression -----------------------------
+    // Reasoning models (glm5.1/zhipu) stream chain-of-thought under `reasoning`.
+    // It must land in reasoning_content, NEVER in the text content — otherwise
+    // response.text() looks like a finished answer and the agent loop terminates
+    // before the model emits its tool call (asset-diagnose "未返回结构化输出").
+
+    struct MockSseHttp {
+        chunks: Vec<String>,
+    }
+
+    #[async_trait::async_trait]
+    impl crate::llm::http::HttpClient for MockSseHttp {
+        async fn post(
+            &self,
+            _url: &str,
+            _headers: Vec<(&str, &str)>,
+            _body: &serde_json::Value,
+            _cancel: tokio_util::sync::CancellationToken,
+        ) -> anyhow::Result<crate::llm::http::HttpResponse> {
+            anyhow::bail!("post is unused in the streaming test")
+        }
+
+        async fn post_streaming(
+            &self,
+            _url: &str,
+            _headers: Vec<(&str, &str)>,
+            _body: &serde_json::Value,
+            _cancel: tokio_util::sync::CancellationToken,
+        ) -> anyhow::Result<crate::llm::http::StreamingHttpResponse> {
+            let items: Vec<anyhow::Result<bytes::Bytes>> = self
+                .chunks
+                .iter()
+                .map(|s| Ok(bytes::Bytes::from(s.clone())))
+                .collect();
+            Ok(crate::llm::http::StreamingHttpResponse {
+                status: 200,
+                retry_after: None,
+                byte_stream: Box::pin(futures::stream::iter(items)),
+                error_body: String::new(),
+            })
+        }
+    }
+
+    fn glm_client(chunks: Vec<String>) -> OpenAiClient {
+        OpenAiClient::new("k".to_string(), "glm-test".to_string())
+            .with_http_client(std::sync::Arc::new(MockSseHttp { chunks }))
+    }
+
+    async fn drain_to_done(client: &OpenAiClient) -> crate::llm::LlmResponse {
+        use crate::llm::{LlmClient, StreamEvent};
+        let mut rx = client
+            .complete_streaming(
+                &[Message::user("go")],
+                None,
+                &[],
+                tokio_util::sync::CancellationToken::new(),
+            )
+            .await
+            .expect("stream opened");
+        let mut done = None;
+        while let Some(ev) = rx.recv().await {
+            if let StreamEvent::Done(resp) = ev {
+                done = Some(resp);
+            }
+        }
+        done.expect("a Done event")
+    }
+
+    #[tokio::test]
+    async fn streaming_reasoning_does_not_leak_into_content_and_keeps_tool_call() {
+        let chunks = vec![
+            "data: {\"choices\":[{\"delta\":{\"reasoning\":\"Let me plan the workers\"}}]}\n\n"
+                .to_string(),
+            "data: {\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_1\",\"function\":{\"name\":\"parallel_task\",\"arguments\":\"{}\"}}]}}]}\n\n"
+                .to_string(),
+            "data: [DONE]\n\n".to_string(),
+        ];
+        let resp = drain_to_done(&glm_client(chunks)).await;
+        // Reasoning must NOT appear as text content.
+        assert_eq!(resp.message.text(), "", "reasoning leaked into content");
+        assert_eq!(
+            resp.message.reasoning_content.as_deref(),
+            Some("Let me plan the workers")
+        );
+        // The tool call still survives, so the agent can act.
+        let calls = resp.message.tool_calls();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].name, "parallel_task");
+    }
+
+    #[tokio::test]
+    async fn streaming_reasoning_only_turn_yields_empty_text() {
+        // A pure "thinking" turn (reasoning, no content, no tool call) must yield empty
+        // text() so the agent loop's looks_incomplete("")==true path CONTINUES instead of
+        // terminating prematurely — the multi-worker diagnose failure root cause.
+        let chunks = vec![
+            "data: {\"choices\":[{\"delta\":{\"reasoning\":\"still thinking, no answer yet\"}}]}\n\n"
+                .to_string(),
+            "data: [DONE]\n\n".to_string(),
+        ];
+        let resp = drain_to_done(&glm_client(chunks)).await;
+        assert_eq!(resp.message.text(), "");
+        assert_eq!(
+            resp.message.reasoning_content.as_deref(),
+            Some("still thinking, no answer yet")
+        );
+        assert!(resp.message.tool_calls().is_empty());
+    }
+
     #[test]
     fn test_apply_directive_forced_function_tool_choice() {
         let mut req = serde_json::json!({ "model": "m" });

core/src/llm/openai.rs

@@ -1,6 +1,6 @@
 [package]
 name = "a3s-code-node"
-version = "4.2.4"
+version = "4.2.5"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"
@@ -11,7 +11,7 @@ description = "A3S Code Node.js bindings - Native addon via napi-rs"
 crate-type = ["cdylib"]
 
 [dependencies]
-a3s-code-core = { version = "4.2.4", path = "../../core", features = ["ahp", "s3", "serve"] }
+a3s-code-core = { version = "4.2.5", path = "../../core", features = ["ahp", "s3", "serve"] }
 napi = { version = "2", features = ["async", "napi6", "serde-json"] }
 napi-derive = "2"
 tokio = { version = "1.35", features = ["full"] }

sdk/node/Cargo.toml

@@ -1,6 +1,6 @@
 {
   "name": "@a3s-lab/code",
-  "version": "4.2.4",
+  "version": "4.2.5",
   "description": "A3S Code - Native Node.js bindings for the coding-agent runtime",
   "main": "index.js",
   "types": "index.d.ts",
@@ -43,11 +43,11 @@
     "test:helpers": "node test-helpers.mjs"
   },
   "optionalDependencies": {
-    "@a3s-lab/code-darwin-arm64": "4.2.4",
-    "@a3s-lab/code-linux-x64-gnu": "4.2.4",
-    "@a3s-lab/code-linux-x64-musl": "4.2.4",
-    "@a3s-lab/code-linux-arm64-gnu": "4.2.4",
-    "@a3s-lab/code-linux-arm64-musl": "4.2.4",
-    "@a3s-lab/code-win32-x64-msvc": "4.2.4"
+    "@a3s-lab/code-darwin-arm64": "4.2.5",
+    "@a3s-lab/code-linux-x64-gnu": "4.2.5",
+    "@a3s-lab/code-linux-x64-musl": "4.2.5",
+    "@a3s-lab/code-linux-arm64-gnu": "4.2.5",
+    "@a3s-lab/code-linux-arm64-musl": "4.2.5",
+    "@a3s-lab/code-win32-x64-msvc": "4.2.5"
   }
 }

sdk/node/examples/package-lock.json

@@ -7,7 +7,7 @@ name = "a3s-code"
 # Keep in sync with crates/code core release. The bootstrap loader fetches
 # the matching native wheel from `https://github.com/AI45Lab/Code/releases/tag/v<version>`
 # at import time.
-version = "4.2.4"
+version = "4.2.5"
 description = "A3S Code Python SDK — pure-Python bootstrap that fetches the native wheel from GitHub Releases"
 readme = "README.md"
 license = {text = "MIT"}

sdk/node/package-lock.json

@@ -31,7 +31,7 @@
 
 # Version is the bootstrap's own version, which equals the matching native
 # wheel version on GH Releases. Bumped by the release workflow.
-__version__ = "4.2.4"
+__version__ = "4.2.5"
 
 _DEFAULT_BASE_URL = "https://github.com/AI45Lab/Code/releases/download"
 _REQUEST_TIMEOUT_S = 120

sdk/node/package.json

@@ -1,6 +1,6 @@
 [package]
 name = "a3s-code-py"
-version = "4.2.4"
+version = "4.2.5"
 edition = "2021"
 authors = ["A3S Lab Team"]
 license = "MIT"
@@ -12,7 +12,7 @@ name = "a3s_code"
 crate-type = ["cdylib"]
 
 [dependencies]
-a3s-code-core = { version = "4.2.4", path = "../../core", features = ["ahp", "s3", "serve"] }
+a3s-code-core = { version = "4.2.5", path = "../../core", features = ["ahp", "s3", "serve"] }
 pyo3 = "0.23"
 tokio = { version = "1.35", features = ["full"] }
 serde_json = "1.0"