fix(chat): 修复历史回放时代码块末行越界崩溃 (#15)

Root cause of the recurring "StringIndexOutOfBoundsException: begin 0,
end 376, length 375" during retryLast/runAgentLoop. fenceSegments in the
reasoning-tag history stripper built the closing-fence range with
`until lineEnd + 1`. When the closing fence is the LAST line and the text
has no trailing newline, lineEnd == text.length, so the range's last index
became text.length — and the downstream text.substring(range) in
transformProtectingCode asked for end = length + 1 (note: end is exactly
length+1 in the report, not a byte/char mixup). Coerce the upper bound to
the text end.

The loop it created: the turn crashed during effectiveAgentHistory()'s
per-message cleanup, the exception text was persisted as an inline error,
and replaying that same assistant message on the next retry hit the same
out-of-bounds slice again. A DeepSeek/QwQ reply whose closing ``` sits on
the final line with no trailing newline triggers it reliably.

Also add a defensive per-transformer fallback in MessageTransformerChain:
a cosmetic cleanup that throws must neither kill the agent loop nor leave
its own exception text persisted as turn content — it now logs the
offending shape and replays the untransformed text.

Regression test: fence closing on the final line without a trailing
newline, including one whose body looks like a reasoning tag.

Co-authored-by: tall-1997 <278631348+tall-1997@users.noreply.github.com>

Author: tall-1997

src/android/app/src/main/java/com/openminis/app/agent/MessageTransformers.kt

@@ -48,7 +48,28 @@ object MessageTransformerChain {
     )
 
     /** Clean an assistant reply before it is replayed to the model. */
-    fun apply(text: String): String = transformers.fold(text) { t, tr -> tr.transform(t) }
+    fun apply(text: String): String = transformers.fold(text) { t, tr ->
+        // A transformer that throws on a pathological assistant turn (the
+        // reported StringIndexOutOfBoundsException — begin 0, end N, length
+        // N-1 — surfaces here, inside ReasoningTagStripper's code-fence /
+        // inline-code masking) must not kill the whole agent loop, and must
+        // not leave the exception's own message persisted as the turn's
+        // content (which is what made the crash recur on every replay of that
+        // message). Fall back to the text as it stood BEFORE this transformer
+        // and log the offending shape so the real boundary bug can be found:
+        // the transform is a cosmetic cleanup, the untransformed text is
+        // always safe to send.
+        try {
+            tr.transform(t)
+        } catch (e: Exception) {
+            com.openminis.app.logging.AppLogger.warning(
+                "MsgTransform",
+                "transformer ${tr.id} threw ${e.javaClass.simpleName}: ${e.message} " +
+                    "on text.length=${t.length} head=\"${t.take(120)}\" — using untransformed text",
+            )
+            t
+        }
+    }
 
     /**
      * Enrich a user message before send. Returns the original text when no
@@ -193,7 +214,18 @@ object MessageTransformerChain {
                 } else if (inFence && trimmed.startsWith(fenceMark) &&
                     trimmed.length == fenceMark.length
                 ) {
-                    out += segStart until lineEnd + 1 to true
+                    // The close fence is the last line with no trailing
+                    // newline: nl < 0 makes lineEnd == text.length, and
+                    // `until lineEnd + 1` would set range.last = text.length,
+                    // so the downstream text.substring(range) asks for
+                    // end = length + 1 → StringIndexOutOfBoundsException
+                    // (the reported "begin 0, end 376, length 375"; an
+                    // assistant turn whose closing ``` sits on the final
+                    // line without a trailing newline — DeepSeek/QwQ do
+                    // this). Coerce the upper bound to the text end: with a
+                    // real newline we keep it (lineEnd + 1 == nl + 1), without
+                    // one there is nothing past lineEnd to include anyway.
+                    out += segStart until (lineEnd + 1).coerceAtMost(text.length) to true
                     segStart = lineEnd + 1
                     inFence = false
                 }

src/android/app/src/test/java/com/openminis/app/agent/ReasoningTagStripperCoverageTest.kt

@@ -77,4 +77,19 @@ class ReasoningTagStripperCoverageTest {
         val text = "before\n```\n<think>demo <b>bold"
         assertEquals(text, apply(text))
     }
+
+    @Test
+    fun `fence closing on the final line without trailing newline does not crash`() {
+        // Regression for StringIndexOutOfBoundsException "begin 0, end N,
+        // length N-1": when the closing fence is the last line and the text
+        // has no trailing newline, fenceSegments produced a range with
+        // last = text.length, and substring(range) asked for end = length+1.
+        // DeepSeek/QwQ replies end exactly like this.
+        val fenced = "body\n```kotlin\nval x = 1\n```"
+        assertEquals(fenced, apply(fenced))
+        // Same shape but the closing fence shares content that looks like a
+        // reasoning tag — the crash hit before the tag logic ever ran.
+        val withTag = "```\n<think>demo</think>\n```"
+        assertEquals(withTag, apply(withTag))
+    }
 }