fix: merge per-token reasoning chunks into single part for GLM models

Some models (e.g., zhipu/glm) emit a separate reasoning-start/delta/end
cycle for every single token, causing each token to render as an
independent 'Thinking:' line in the TUI.

Fix by tracking the last reasoning part and reusing it when consecutive
reasoning-start events arrive, instead of creating a new part each time.
The merged part is finalized at text-start or finish-step.

Also normalize newlines in ReasoningPart render as defense-in-depth.

Author: 金双

packages/opencode/src/cli/cmd/tui/context/sync.tsx

@@ -323,7 +323,8 @@ export const { use: useSync, provider: SyncProvider } = createSimpleContext({
               const part = draft[result.index]
               const field = event.properties.field as keyof typeof part
               const existing = part[field] as string | undefined
-              ;(part[field] as string) = (existing ?? "") + event.properties.delta
+              const delta = event.properties.delta
+              ;(part[field] as string) = (existing ?? "") + delta
             }),
           )
           break

packages/opencode/src/cli/cmd/tui/routes/session/index.tsx

@@ -1436,7 +1436,17 @@ function ReasoningPart(props: { last: boolean; part: ReasoningPart; message: Ass
   const content = createMemo(() => {
     // Filter out redacted reasoning chunks from OpenRouter
     // OpenRouter sends encrypted reasoning data that appears as [REDACTED]
-    return props.part.text.replace("[REDACTED]", "").trim()
+    let text = props.part.text.replace("[REDACTED]", "").trim()
+    // Normalize newlines for models that stream each token with its own newline
+    // (e.g., zhipu/glm). Preserve paragraph breaks (\n\n) but collapse single
+    // newlines that are just token boundaries into spaces.
+    text = text
+      .replace(/\r\n/g, "\n")
+      .replace(/\n{2,}/g, "\x00PARA\x00") // Protect paragraph breaks
+      .replace(/\n/g, " ")                 // Single newlines → space
+      .replace(/\x00PARA\x00/g, "\n\n")    // Restore paragraph breaks
+      .replace(/ {2,}/g, " ")              // Collapse multiple spaces
+    return text
   })
   return (
     <Show when={content() && ctx.showThinking()}>

packages/opencode/src/session/processor.ts

@@ -211,13 +211,35 @@ export namespace SessionProcessor {
         })
 
         const handleEvent = Effect.fn("SessionProcessor.handleEvent")(function* (value: StreamEvent) {
+          // Finalize a merged reasoning part (for models that emit per-token reasoning chunks)
+          function* finalizeReasoning() {
+            const entry = (ctx as any)._lastReasoningEntry
+            if (!entry) return
+            entry.text = entry.text.trimEnd()
+            entry.time = { ...entry.time, end: Date.now() }
+            yield* session.updatePart(entry)
+            ;(ctx as any)._lastReasoningPartId = undefined
+            ;(ctx as any)._lastReasoningEntry = undefined
+          }
+
           switch (value.type) {
             case "start":
               yield* status.set(ctx.sessionID, { type: "busy" })
               return
 
             case "reasoning-start":
               if (value.id in ctx.reasoningMap) return
+              // Some models (e.g., zhipu/glm) emit a separate reasoning-start/delta/end
+              // cycle for every single token. Merge consecutive reasoning chunks into
+              // one part to avoid per-token line rendering in the TUI.
+              if ((ctx as any)._lastReasoningPartId) {
+                // Reuse the previous reasoning part — map this new id to the same part
+                const prev = (ctx as any)._lastReasoningEntry
+                if (prev) {
+                  ctx.reasoningMap[value.id] = prev
+                  return
+                }
+              }
               ctx.reasoningMap[value.id] = {
                 id: PartID.ascending(),
                 messageID: ctx.assistantMessage.id,
@@ -227,6 +249,8 @@ export namespace SessionProcessor {
                 time: { start: Date.now() },
                 metadata: value.providerMetadata,
               }
+              ;(ctx as any)._lastReasoningPartId = ctx.reasoningMap[value.id].id
+              ;(ctx as any)._lastReasoningEntry = ctx.reasoningMap[value.id]
               yield* session.updatePart(ctx.reasoningMap[value.id])
               return
 
@@ -245,10 +269,10 @@ export namespace SessionProcessor {
 
             case "reasoning-end":
               if (!(value.id in ctx.reasoningMap)) return
-              ctx.reasoningMap[value.id].text = ctx.reasoningMap[value.id].text.trimEnd()
-              ctx.reasoningMap[value.id].time = { ...ctx.reasoningMap[value.id].time, end: Date.now() }
+              // Don't trimEnd or finalize yet — more reasoning chunks may follow.
+              // Just clean up the map entry for this id but keep the part reference
+              // alive via _lastReasoningEntry for potential reuse.
               if (value.providerMetadata) ctx.reasoningMap[value.id].metadata = value.providerMetadata
-              yield* session.updatePart(ctx.reasoningMap[value.id])
               delete ctx.reasoningMap[value.id]
               return
 
@@ -351,6 +375,7 @@ export namespace SessionProcessor {
               return
 
             case "finish-step": {
+              yield* finalizeReasoning()
               const usage = Session.getUsage({
                 model: ctx.model,
                 usage: value.usage,
@@ -398,6 +423,7 @@ export namespace SessionProcessor {
             }
 
             case "text-start":
+              yield* finalizeReasoning()
               ctx.currentText = {
                 id: PartID.ascending(),
                 messageID: ctx.assistantMessage.id,