Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@fd688f5473c00425188f708047e3ab8b2cefe9f8

Author: github-actions[bot]

freebuff/cli/release/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freebuff",
-  "version": "0.0.158",
+  "version": "0.0.159",
   "description": "The world's strongest free coding agent",
   "license": "MIT",
   "bin": {

packages/agent-runtime/src/__tests__/stream-parser-think-leak.test.ts

@@ -0,0 +1,172 @@
+/**
+ * End-to-end over processStream: a lane that puts a thinking model's chain of
+ * thought in `content` instead of `reasoning_content` must not reach a surface
+ * as prose, and must never reach one carrying a literal `</think>`.
+ */
+import { TEST_AGENT_RUNTIME_IMPL } from '@codebuff/common/testing/impl/agent-runtime'
+import { getInitialSessionState } from '@codebuff/common/types/session-state'
+import { beforeEach, describe, expect, it } from 'bun:test'
+
+import { mockFileContext } from './test-utils'
+import { processStream } from '../tools/stream-parser'
+
+import type { AgentTemplate } from '../templates/types'
+import type {
+  AgentRuntimeDeps,
+  AgentRuntimeScopedDeps,
+} from '@codebuff/common/types/contracts/agent-runtime'
+import type { StreamChunk } from '@codebuff/common/types/contracts/llm'
+import type { Message } from '@codebuff/common/types/messages/codebuff-message'
+import type { PrintModeEvent } from '@codebuff/common/types/print-mode'
+import type { PromptResult } from '@codebuff/common/util/error'
+
+const testAgentTemplate: AgentTemplate = {
+  id: 'test-agent',
+  displayName: 'Test Agent',
+  spawnerPrompt: 'Test agent',
+  model: 'deepseek/deepseek-v4-flash',
+  inputSchema: {},
+  outputMode: 'structured_output',
+  includeMessageHistory: true,
+  inheritParentSystemPrompt: false,
+  mcpServers: {},
+  toolNames: ['read_files', 'end_turn'],
+  spawnableAgents: [],
+  systemPrompt: 'Test system prompt',
+  instructionsPrompt: 'Test instructions',
+  stepPrompt: 'Test step prompt',
+}
+
+/** What a surface would render: streamed text, and the thinking box. */
+interface Rendered {
+  text: string
+  reasoning: string
+  fullResponse: string
+}
+
+describe('processStream — leaked think tags', () => {
+  let agentRuntimeImpl: AgentRuntimeDeps & AgentRuntimeScopedDeps
+
+  beforeEach(() => {
+    agentRuntimeImpl = { ...TEST_AGENT_RUNTIME_IMPL, sendAction: () => {} }
+  })
+
+  async function render(
+    chunks: StreamChunk[],
+    priorHistory: Message[] = [],
+  ): Promise<Rendered> {
+    async function* stream(): AsyncGenerator<
+      StreamChunk,
+      PromptResult<string | null>
+    > {
+      for (const chunk of chunks) yield chunk
+      return { aborted: false, value: 'msg-id' }
+    }
+
+    const sessionState = getInitialSessionState(mockFileContext)
+    const agentState = sessionState.mainAgentState
+    agentState.messageHistory = [...priorHistory]
+
+    let text = ''
+    let reasoning = ''
+    const result = await processStream({
+      ...agentRuntimeImpl,
+      agentContext: {},
+      agentState,
+      agentStepId: 'test-step-id',
+      agentTemplate: testAgentTemplate,
+      ancestorRunIds: [],
+      clientSessionId: 'test-session',
+      fileContext: mockFileContext,
+      fingerprintId: 'test-fingerprint',
+      fullResponse: '',
+      localAgentTemplates: { 'test-agent': testAgentTemplate },
+      messages: agentState.messageHistory,
+      prompt: 'test prompt',
+      repoId: undefined,
+      repoUrl: undefined,
+      runId: 'test-run-id',
+      signal: new AbortController().signal,
+      stream: stream(),
+      system: 'test system',
+      tools: {},
+      userId: 'test-user',
+      userInputId: 'test-input-id',
+      onCostCalculated: async () => {},
+      onResponseChunk: (chunk: string | PrintModeEvent) => {
+        if (typeof chunk === 'string') {
+          text += chunk
+        } else if (chunk.type === 'reasoning_delta') {
+          reasoning += chunk.text
+        }
+      },
+    })
+
+    return { text, reasoning, fullResponse: result.fullResponse }
+  }
+
+  const textChunks = (...texts: string[]): StreamChunk[] =>
+    texts.map((t) => ({ type: 'text' as const, text: t }))
+
+  const leakedAssistantTurn: Message[] = [
+    {
+      role: 'assistant',
+      content: [{ type: 'text', text: 'earlier thought</think>earlier answer' }],
+    } as Message,
+  ]
+
+  it('routes a paired block to the thinking box', async () => {
+    const { text, reasoning } = await render(
+      textChunks('<think>weigh the options</think>', 'The answer.'),
+    )
+    expect(reasoning).toBe('weigh the options')
+    expect(text).toBe('The answer.')
+  })
+
+  it('never streams a bare close marker, even unarmed', async () => {
+    const { text, reasoning } = await render(
+      textChunks('Saw the anchor.', '</think>', 'Now the fix.'),
+    )
+    expect(text).toBe('Saw the anchor.Now the fix.')
+    expect(text).not.toContain('</think>')
+    expect(reasoning).toBe('')
+  })
+
+  it('reclassifies the head once a prior turn proved the lane leaks', async () => {
+    const { text, reasoning } = await render(
+      textChunks('Ключевая зацепка: ', 'the bundle knows.', '</think>Real answer.'),
+      leakedAssistantTurn,
+    )
+    expect(reasoning).toBe('Ключевая зацепка: the bundle knows.')
+    expect(text).toBe('Real answer.')
+  })
+
+  it('releases the head as text when the marker never comes', async () => {
+    // The lossless guarantee: a wrong guess delays an answer, never hides it.
+    const { text, reasoning } = await render(
+      textChunks('A clean answer this time.'),
+      leakedAssistantTurn,
+    )
+    expect(text).toBe('A clean answer this time.')
+    expect(reasoning).toBe('')
+  })
+
+  it('stands down when the lane does populate native reasoning', async () => {
+    const { text, reasoning } = await render(
+      [
+        { type: 'reasoning', text: 'native thought' },
+        ...textChunks('The answer.'),
+      ],
+      leakedAssistantTurn,
+    )
+    expect(reasoning).toBe('native thought')
+    expect(text).toBe('The answer.')
+  })
+
+  it('leaves fullResponse raw so the turn-end and arming signals survive', async () => {
+    // isThinkOnlyResponse reads fullResponse to keep a thinking-only step from
+    // ending the turn; historyLeaksThinkTags reads the history to arm the next.
+    const { fullResponse } = await render(textChunks('thought', '</think>done'))
+    expect(fullResponse).toBe('thought</think>done')
+  })
+})

packages/agent-runtime/src/tools/stream-parser.ts

@@ -17,8 +17,14 @@ import {
   tryTransformAgentToolCall,
 } from './tool-executor'
 import { withSystemTags } from '../util/messages'
+import {
+  historyLeaksThinkTags,
+  stripThinkScaffolding,
+  ThinkTagStream,
+} from '../util/think-tag-stream'
 
 import type { CustomToolCall, ExecuteToolCallParams } from './tool-executor'
+import type { ThinkStreamSegment } from '../util/think-tag-stream'
 import type { AgentTemplate } from '../templates/types'
 import type { FileProcessingState } from './handlers/tool/write-file'
 import type { ToolName } from '@codebuff/common/tools/constants'
@@ -170,6 +176,31 @@ export async function processStream(
   } = params
   const fullResponseChunks: string[] = [fullResponse]
 
+  // === LEAKED-REASONING SPLIT ===
+  // Reasoning that a lane failed to put in its native field arrives here as
+  // ordinary text, tags and all. Reclassify it before it reaches a surface, so
+  // the thinking box is the only place a chain of thought is ever rendered.
+  // See util/think-tag-stream.ts for the three shapes and why the implicit-open
+  // rule is armed from the history rather than from a model id.
+  const thinkTagStream = new ThinkTagStream({
+    implicitOpen: historyLeaksThinkTags(agentState.messageHistory),
+  })
+  const emitThinkSegments = (segments: ThinkStreamSegment[]): void => {
+    for (const segment of segments) {
+      if (segment.type === 'text') {
+        onResponseChunk(segment.text)
+      } else {
+        onResponseChunk({
+          type: 'reasoning_delta',
+          text: segment.text,
+          ancestorRunIds,
+          runId,
+          agentId: agentState.agentId,
+        })
+      }
+    }
+  }
+
   // === MUTABLE STATE ===
   const toolResults: ToolMessage[] = []
   const toolResultsToAddToMessageHistory: ToolMessage[] = []
@@ -358,8 +389,19 @@ export async function processStream(
     onResponseChunk: (chunk) => {
       if (chunk.type === 'text') {
         if (chunk.text) {
+          // Raw, like fullResponse: the history is where the leak evidence and
+          // the thinking-only turn-end signal live.
           assistantMessages.push(assistantMessage(chunk.text))
         }
+        // This event is the CONSOLIDATED fallback for consumers that did not
+        // take the streamed deltas — the desktop harness renders it only when
+        // nothing streamed, which is exactly the thinking-only step where every
+        // delta above went to the thinking box instead. Forwarding it raw would
+        // put the scaffolding back on screen through the side door.
+        const visible = stripThinkScaffolding(chunk.text)
+        if (visible !== chunk.text) {
+          return onResponseChunk({ ...chunk, text: visible })
+        }
       } else if (chunk.type === 'error') {
         // do nothing
       } else {
@@ -433,6 +475,10 @@ export async function processStream(
           }
         }
         if (chunk.text) {
+          // A lane that populates the native reasoning field is by definition
+          // not putting the thought in `content`, so this step is not leaking
+          // and anything held on speculation is the answer.
+          emitThinkSegments(thinkTagStream.disarmImplicitOpen())
           onResponseChunk({
             type: 'reasoning_delta',
             text: chunk.text,
@@ -442,7 +488,11 @@ export async function processStream(
           })
         }
       } else if (chunk.type === 'text') {
-        onResponseChunk(chunk.text)
+        // Deliberately the RAW text into fullResponse and the message history:
+        // isThinkOnlyResponse reads it to keep a thinking-only step from ending
+        // the turn, and historyLeaksThinkTags reads it to arm the next step.
+        // Stripping it here would erase both signals.
+        emitThinkSegments(thinkTagStream.push(chunk.text))
         fullResponseChunks.push(chunk.text)
       } else if (chunk.type === 'error') {
         onResponseChunk(chunk)
@@ -503,6 +553,12 @@ export async function processStream(
       }
     }
 
+    // The step's content is complete: release anything the split still holds,
+    // before the tool-completion await below, so a released head keeps its
+    // place ahead of this step's tool events. `flush` is idempotent, so the
+    // safety-net call in `finally` is a no-op on this path.
+    emitThinkSegments(thinkTagStream.flush())
+
     // Retry-outcome signal: this step streamed to completion (no new
     // recovery, no user abort) while the history tail still carries a
     // recovery streak — meaning the forced-step retry rescued the turn.
@@ -541,6 +597,11 @@ export async function processStream(
     }
   } finally {
     // === FINALIZATION ===
+    // Release anything the think-tag split is still holding — a partial tag
+    // that never completed, or a head held for an orphan `</think>` that never
+    // came. Runs on the abort paths too, so speculation can never lose text.
+    emitThinkSegments(thinkTagStream.flush())
+
     // Trigger cleanup of the processStreamWithTools generator so it flushes any
     // remaining buffered text to assistantMessages before we build the history.
     // On path B (AbortError thrown mid-stream) the generator is already completed