cli: Convert streamed <think> tags to a thinking block

Author: jahooma

cli/src/types/chat.ts

@@ -15,6 +15,8 @@ export type TextContentBlock = {
   isCollapsed?: boolean
   thinkingId?: string
   userOpened?: boolean
+  /** True if this is a reasoning block from a <think> tag that hasn't been closed yet */
+  thinkingOpen?: boolean
 }
 export type HtmlContentBlock = {
   type: 'html'

cli/src/utils/__tests__/send-message-helpers.test.ts

@@ -438,6 +438,166 @@ describe('appendTextToRootStream', () => {
 
     expect(result).toBe(blocks)
   })
+
+  // Think tag parsing tests
+  test('parses think tags in text and creates reasoning blocks', () => {
+    const result = appendTextToRootStream([], {
+      type: 'text',
+      text: 'Before <think>My thoughts</think> after',
+    })
+
+    expect(result).toHaveLength(3)
+    expect((result[0] as any).content).toBe('Before ')
+    expect((result[0] as any).textType).toBe('text')
+    expect((result[1] as any).content).toBe('My thoughts')
+    expect((result[1] as any).textType).toBe('reasoning')
+    expect((result[1] as any).isCollapsed).toBe(true)
+    expect((result[2] as any).content).toBe(' after')
+    expect((result[2] as any).textType).toBe('text')
+  })
+
+  test('handles unclosed think tag', () => {
+    const result = appendTextToRootStream([], {
+      type: 'text',
+      text: 'Before <think>unclosed thoughts',
+    })
+
+    expect(result).toHaveLength(2)
+    expect((result[0] as any).content).toBe('Before ')
+    expect((result[1] as any).content).toBe('unclosed thoughts')
+    expect((result[1] as any).textType).toBe('reasoning')
+    expect((result[1] as any).thinkingOpen).toBe(true)
+  })
+
+  test('continues appending to open thinking block', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'text',
+        content: 'initial thoughts',
+        textType: 'reasoning',
+        isCollapsed: true,
+        thinkingOpen: true,
+      },
+    ]
+
+    const result = appendTextToRootStream(blocks, {
+      type: 'text',
+      text: ' more thoughts',
+    })
+
+    expect(result).toHaveLength(1)
+    expect((result[0] as any).content).toBe('initial thoughts more thoughts')
+    expect((result[0] as any).textType).toBe('reasoning')
+  })
+
+  test('closes thinking block when close tag received', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'text',
+        content: 'initial thoughts',
+        textType: 'reasoning',
+        isCollapsed: true,
+        thinkingOpen: true,
+      },
+    ]
+
+    const result = appendTextToRootStream(blocks, {
+      type: 'text',
+      text: ' final</think> regular text',
+    })
+
+    expect(result).toHaveLength(2)
+    expect((result[0] as any).content).toBe('initial thoughts final')
+    expect((result[0] as any).textType).toBe('reasoning')
+    expect((result[0] as any).thinkingOpen).toBe(false)
+    expect((result[1] as any).content).toBe(' regular text')
+    expect((result[1] as any).textType).toBe('text')
+  })
+
+  test('handles multiple think tags in one chunk', () => {
+    const result = appendTextToRootStream([], {
+      type: 'text',
+      text: '<think>first</think> middle <think>second</think>',
+    })
+
+    expect(result).toHaveLength(3)
+    expect((result[0] as any).textType).toBe('reasoning')
+    expect((result[0] as any).content).toBe('first')
+    expect((result[1] as any).textType).toBe('text')
+    expect((result[1] as any).content).toBe(' middle ')
+    expect((result[2] as any).textType).toBe('reasoning')
+    expect((result[2] as any).content).toBe('second')
+  })
+
+  test('handles think tag at start of text', () => {
+    const result = appendTextToRootStream([], {
+      type: 'text',
+      text: '<think>thoughts</think> after',
+    })
+
+    expect(result).toHaveLength(2)
+    expect((result[0] as any).textType).toBe('reasoning')
+    expect((result[0] as any).content).toBe('thoughts')
+    expect((result[1] as any).textType).toBe('text')
+    expect((result[1] as any).content).toBe(' after')
+  })
+
+  test('text without think tags works normally', () => {
+    const result = appendTextToRootStream([], {
+      type: 'text',
+      text: 'Just regular text without tags',
+    })
+
+    expect(result).toHaveLength(1)
+    expect((result[0] as any).content).toBe('Just regular text without tags')
+    expect((result[0] as any).textType).toBe('text')
+  })
+
+  test('closes thinking block when receiving just </think> tag', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'text',
+        content: 'thoughts',
+        textType: 'reasoning',
+        isCollapsed: true,
+        thinkingOpen: true,
+      },
+    ]
+
+    const result = appendTextToRootStream(blocks, {
+      type: 'text',
+      text: '</think>',
+    })
+
+    expect(result).toHaveLength(1)
+    expect((result[0] as any).content).toBe('thoughts')
+    expect((result[0] as any).textType).toBe('reasoning')
+    expect((result[0] as any).thinkingOpen).toBe(false)
+  })
+
+  test('closes thinking block and adds text after </think>', () => {
+    const blocks: ContentBlock[] = [
+      {
+        type: 'text',
+        content: 'thoughts',
+        textType: 'reasoning',
+        isCollapsed: true,
+        thinkingOpen: true,
+      },
+    ]
+
+    const result = appendTextToRootStream(blocks, {
+      type: 'text',
+      text: '</think>after',
+    })
+
+    expect(result).toHaveLength(2)
+    expect((result[0] as any).content).toBe('thoughts')
+    expect((result[0] as any).textType).toBe('reasoning')
+    expect((result[0] as any).thinkingOpen).toBe(false)
+    expect((result[1] as any).content).toBe('after')
+    expect((result[1] as any).textType).toBe('text')
+  })
 })
 
 describe('extractPlanFromBuffer', () => {

cli/src/utils/__tests__/think-tag-parser.test.ts

@@ -0,0 +1,155 @@
+import { describe, test, expect } from 'bun:test'
+
+import {
+  parseThinkTags,
+  getPartialTagLength,
+  THINK_OPEN_TAG,
+  THINK_CLOSE_TAG,
+} from '../think-tag-parser'
+
+describe('parseThinkTags', () => {
+  test('returns empty array for empty string', () => {
+    expect(parseThinkTags('')).toEqual([])
+  })
+
+  test('returns single text segment for text without tags', () => {
+    expect(parseThinkTags('Hello world')).toEqual([
+      { type: 'text', content: 'Hello world' },
+    ])
+  })
+
+  test('parses single think tag', () => {
+    expect(parseThinkTags('<think>My thoughts</think>')).toEqual([
+      { type: 'thinking', content: 'My thoughts' },
+    ])
+  })
+
+  test('parses think tag with surrounding text', () => {
+    expect(parseThinkTags('Before <think>thinking</think> after')).toEqual([
+      { type: 'text', content: 'Before ' },
+      { type: 'thinking', content: 'thinking' },
+      { type: 'text', content: ' after' },
+    ])
+  })
+
+  test('parses multiple think tags', () => {
+    expect(
+      parseThinkTags('Start <think>first</think> middle <think>second</think> end'),
+    ).toEqual([
+      { type: 'text', content: 'Start ' },
+      { type: 'thinking', content: 'first' },
+      { type: 'text', content: ' middle ' },
+      { type: 'thinking', content: 'second' },
+      { type: 'text', content: ' end' },
+    ])
+  })
+
+  test('handles unclosed think tag at end', () => {
+    expect(parseThinkTags('Before <think>unclosed thinking')).toEqual([
+      { type: 'text', content: 'Before ' },
+      { type: 'thinking', content: 'unclosed thinking' },
+    ])
+  })
+
+  test('handles think tag at start', () => {
+    expect(parseThinkTags('<think>thoughts</think> after')).toEqual([
+      { type: 'thinking', content: 'thoughts' },
+      { type: 'text', content: ' after' },
+    ])
+  })
+
+  test('handles think tag at end', () => {
+    expect(parseThinkTags('before <think>thoughts</think>')).toEqual([
+      { type: 'text', content: 'before ' },
+      { type: 'thinking', content: 'thoughts' },
+    ])
+  })
+
+  test('handles empty think tag', () => {
+    expect(parseThinkTags('before <think></think> after')).toEqual([
+      { type: 'text', content: 'before ' },
+      { type: 'text', content: ' after' },
+    ])
+  })
+
+  test('handles multiline content in think tag', () => {
+    const input = 'Before\n<think>Line 1\nLine 2\nLine 3</think>\nAfter'
+    expect(parseThinkTags(input)).toEqual([
+      { type: 'text', content: 'Before\n' },
+      { type: 'thinking', content: 'Line 1\nLine 2\nLine 3' },
+      { type: 'text', content: '\nAfter' },
+    ])
+  })
+
+  test('handles consecutive think tags', () => {
+    expect(parseThinkTags('<think>first</think><think>second</think>')).toEqual([
+      { type: 'thinking', content: 'first' },
+      { type: 'thinking', content: 'second' },
+    ])
+  })
+
+  test('preserves whitespace inside think tags', () => {
+    expect(parseThinkTags('<think>  spaced content  </think>')).toEqual([
+      { type: 'thinking', content: '  spaced content  ' },
+    ])
+  })
+
+  test('handles only opening tag', () => {
+    expect(parseThinkTags('<think>started thinking')).toEqual([
+      { type: 'thinking', content: 'started thinking' },
+    ])
+  })
+})
+
+describe('getPartialTagLength', () => {
+  test('returns 0 for text without partial tags', () => {
+    expect(getPartialTagLength('hello world')).toBe(0)
+    expect(getPartialTagLength('some text')).toBe(0)
+    expect(getPartialTagLength('')).toBe(0)
+  })
+
+  test('detects partial opening tag prefixes', () => {
+    expect(getPartialTagLength('text<')).toBe(1)
+    expect(getPartialTagLength('text<t')).toBe(2)
+    expect(getPartialTagLength('text<th')).toBe(3)
+    expect(getPartialTagLength('text<thi')).toBe(4)
+    expect(getPartialTagLength('text<thin')).toBe(5)
+    expect(getPartialTagLength('text<think')).toBe(6)
+  })
+
+  test('detects partial closing tag prefixes', () => {
+    expect(getPartialTagLength('text</')).toBe(2)
+    expect(getPartialTagLength('text</t')).toBe(3)
+    expect(getPartialTagLength('text</th')).toBe(4)
+    expect(getPartialTagLength('text</thi')).toBe(5)
+    expect(getPartialTagLength('text</thin')).toBe(6)
+    expect(getPartialTagLength('text</think')).toBe(7)
+  })
+
+  test('returns 0 for complete tags', () => {
+    expect(getPartialTagLength('text<think>')).toBe(0)
+    expect(getPartialTagLength('text</think>')).toBe(0)
+  })
+
+  test('returns 0 for non-tag < character', () => {
+    expect(getPartialTagLength('text<x')).toBe(0)
+    expect(getPartialTagLength('text<a')).toBe(0)
+    expect(getPartialTagLength('text</x')).toBe(0)
+  })
+
+  test('handles just the partial tag character', () => {
+    expect(getPartialTagLength('<')).toBe(1)
+    expect(getPartialTagLength('<t')).toBe(2)
+    expect(getPartialTagLength('</')).toBe(2)
+  })
+})
+
+describe('tag constants', () => {
+  test('THINK_OPEN_TAG is correct', () => {
+    expect(THINK_OPEN_TAG).toBe('<think>')
+  })
+
+  test('THINK_CLOSE_TAG is correct', () => {
+    expect(THINK_CLOSE_TAG).toBe('</think>')
+  })
+})