@swarmclawai/swarmclaw 1.8.1 → 1.8.11

package/README.md

@@ -399,6 +399,14 @@ Operational docs: https://swarmclaw.ai/docs/observability
 
 ## Releases
 
+### v1.8.11 Highlights
+
+DeepSeek tool-use hotfix for issue [#67](https://github.com/swarmclawai/swarmclaw/issues/67).
+
+- **DeepSeek reasoning replay.** Stored assistant turns now keep provider-native `reasoning_content` separately from visible text and send it back to DeepSeek on follow-up tool-use turns.
+- **Streaming parity.** Direct OpenAI-compatible streams and LangGraph agent streams both preserve `reasoning_content` while continuing to show reasoning through SwarmClaw's existing thinking surface.
+- **Regression coverage.** Added tests for DeepSeek history replay and the LangChain bridge selection path.
+
 ### v1.8.1 Highlights
 
 Operator evidence release: a focused follow-up that makes release and mission review easier to scan.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swarmclawai/swarmclaw",
-  "version": "1.8.1",
+  "version": "1.8.11",
   "description": "Build and run autonomous AI agents with OpenClaw, Hermes, multiple model providers, orchestration, delegation, memory, skills, schedules, and chat connectors.",
   "main": "electron-dist/main.js",
   "license": "MIT",

package/src/lib/providers/deepseek-reasoning-chat-openai.ts

@@ -0,0 +1,305 @@
+import {
+  ChatOpenAI,
+  ChatOpenAICompletions,
+  convertMessagesToCompletionsMessageParams,
+  type ChatOpenAIFields,
+} from '@langchain/openai'
+import {
+  AIMessage,
+  AIMessageChunk,
+  isAIMessage,
+  type BaseMessage,
+  type BaseMessageChunk,
+  type UsageMetadata,
+} from '@langchain/core/messages'
+import { ChatGenerationChunk, type ChatGeneration, type ChatResult } from '@langchain/core/outputs'
+import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager'
+import type { OpenAI as OpenAIClient } from 'openai'
+
+export const REASONING_CONTENT_MD_KEY = 'reasoningContentDelta'
+
+type ChatCompletionMessageParam = OpenAIClient.Chat.Completions.ChatCompletionMessageParam
+
+export function extractReasoningContentDelta(delta: Record<string, unknown> | null | undefined): string {
+  if (!delta) return ''
+  if (typeof delta.reasoning_content === 'string') return delta.reasoning_content
+  if (typeof delta.reasoning === 'string') return delta.reasoning
+  return ''
+}
+
+export function getReasoningContentFromLangChainMessage(message: Pick<BaseMessage, 'additional_kwargs'>): string {
+  const additionalKwargs = message.additional_kwargs || {}
+  const reasoningContent = additionalKwargs.reasoning_content
+  if (typeof reasoningContent === 'string' && reasoningContent.length > 0) return reasoningContent
+  const reasoning = additionalKwargs.reasoning
+  return typeof reasoning === 'string' ? reasoning : ''
+}
+
+export function attachReasoningContentToCompletionsMessages<T extends ChatCompletionMessageParam>(
+  messagesMapped: T[],
+  sourceMessages: BaseMessage[],
+): T[] {
+  return messagesMapped.map((message, index) => {
+    const reasoningContent = getReasoningContentFromLangChainMessage(sourceMessages[index])
+    if (message.role !== 'assistant' || !reasoningContent) return message
+    return {
+      ...message,
+      reasoning_content: reasoningContent,
+    } as T
+  })
+}
+
+export function mergeReasoningContentIntoMessage<T extends { additional_kwargs: Record<string, unknown> }>(
+  message: T,
+  delta: Record<string, unknown> | null | undefined,
+): T {
+  const reasoningContent = extractReasoningContentDelta(delta)
+  if (!reasoningContent) return message
+  const existing = message.additional_kwargs.reasoning_content
+  const nextReasoningContent = typeof existing === 'string' && existing.length > 0
+    ? existing.endsWith(reasoningContent) ? existing : `${existing}${reasoningContent}`
+    : reasoningContent
+  message.additional_kwargs = {
+    ...message.additional_kwargs,
+    reasoning_content: nextReasoningContent,
+  }
+  return message
+}
+
+export function shouldUseDeepSeekReasoningBridge(
+  provider: string | null | undefined,
+  endpoint: string | null | undefined,
+): boolean {
+  if (provider === 'deepseek') return true
+  if (!endpoint) return false
+  try {
+    return new URL(endpoint).hostname === 'api.deepseek.com'
+  } catch {
+    return false
+  }
+}
+
+export function createReasoningContentMetadata(reasoningContentDelta: string): Record<string, string> {
+  return { [REASONING_CONTENT_MD_KEY]: reasoningContentDelta }
+}
+
+class DeepSeekReasoningChatOpenAICompletions extends ChatOpenAICompletions {
+  override async _generate(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun,
+  ): Promise<ChatResult> {
+    options.signal?.throwIfAborted()
+    const usageMetadata: UsageMetadata = {
+      input_tokens: 0,
+      output_tokens: 0,
+      total_tokens: 0,
+    }
+    const params = this.invocationParams(options)
+    const messagesMapped = attachReasoningContentToCompletionsMessages(
+      convertMessagesToCompletionsMessageParams({
+        messages,
+        model: this.model,
+      }),
+      messages,
+    )
+    if (params.stream) {
+      const stream = this._streamResponseChunks(messages, options, runManager)
+      const finalChunks: Record<string, ChatGenerationChunk> = {}
+      for await (const chunk of stream) {
+        chunk.message.response_metadata = {
+          ...chunk.generationInfo,
+          ...chunk.message.response_metadata,
+        }
+        const index = chunk.generationInfo?.completion ?? 0
+        if (finalChunks[index] === undefined) finalChunks[index] = chunk
+        else finalChunks[index] = finalChunks[index].concat(chunk)
+      }
+      const generations = Object.entries(finalChunks)
+        .sort(([aKey], [bKey]) => parseInt(aKey, 10) - parseInt(bKey, 10))
+        .map(([, value]) => value)
+      const { functions, function_call } = this.invocationParams(options)
+      const promptTokenUsage = await this._getEstimatedTokenCountFromPrompt(messages, functions, function_call)
+      const completionTokenUsage = await this._getNumTokensFromGenerations(generations)
+      usageMetadata.input_tokens = promptTokenUsage
+      usageMetadata.output_tokens = completionTokenUsage
+      usageMetadata.total_tokens = promptTokenUsage + completionTokenUsage
+      return {
+        generations,
+        llmOutput: {
+          estimatedTokenUsage: {
+            promptTokens: usageMetadata.input_tokens,
+            completionTokens: usageMetadata.output_tokens,
+            totalTokens: usageMetadata.total_tokens,
+          },
+        },
+      }
+    }
+
+    const data = await this.completionWithRetry({
+      ...params,
+      stream: false,
+      messages: messagesMapped,
+    }, {
+      signal: options?.signal,
+      ...options?.options,
+    })
+    const {
+      completion_tokens: completionTokens,
+      prompt_tokens: promptTokens,
+      total_tokens: totalTokens,
+      prompt_tokens_details: promptTokensDetails,
+      completion_tokens_details: completionTokensDetails,
+    } = data?.usage ?? {}
+    if (completionTokens) usageMetadata.output_tokens = (usageMetadata.output_tokens ?? 0) + completionTokens
+    if (promptTokens) usageMetadata.input_tokens = (usageMetadata.input_tokens ?? 0) + promptTokens
+    if (totalTokens) usageMetadata.total_tokens = (usageMetadata.total_tokens ?? 0) + totalTokens
+    if (promptTokensDetails?.audio_tokens !== null || promptTokensDetails?.cached_tokens !== null) {
+      usageMetadata.input_token_details = {
+        ...(promptTokensDetails?.audio_tokens !== null && { audio: promptTokensDetails?.audio_tokens }),
+        ...(promptTokensDetails?.cached_tokens !== null && { cache_read: promptTokensDetails?.cached_tokens }),
+      }
+    }
+    if (completionTokensDetails?.audio_tokens !== null || completionTokensDetails?.reasoning_tokens !== null) {
+      usageMetadata.output_token_details = {
+        ...(completionTokensDetails?.audio_tokens !== null && { audio: completionTokensDetails?.audio_tokens }),
+        ...(completionTokensDetails?.reasoning_tokens !== null && { reasoning: completionTokensDetails?.reasoning_tokens }),
+      }
+    }
+    const generations = []
+    for (const part of data?.choices ?? []) {
+      const generation: ChatGeneration = {
+        text: part.message?.content ?? '',
+        message: this._convertCompletionsMessageToBaseMessage(part.message ?? { role: 'assistant' }, data),
+      }
+      generation.generationInfo = {
+        ...(part.finish_reason ? { finish_reason: part.finish_reason } : {}),
+        ...(part.logprobs ? { logprobs: part.logprobs } : {}),
+      }
+      if (isAIMessage(generation.message)) generation.message.usage_metadata = usageMetadata
+      generation.message = new AIMessage(Object.fromEntries(
+        Object.entries(generation.message).filter(([key]) => !key.startsWith('lc_')),
+      ) as ConstructorParameters<typeof AIMessage>[0])
+      generations.push(generation)
+    }
+    return {
+      generations,
+      llmOutput: {
+        tokenUsage: {
+          promptTokens: usageMetadata.input_tokens,
+          completionTokens: usageMetadata.output_tokens,
+          totalTokens: usageMetadata.total_tokens,
+        },
+      },
+    }
+  }
+
+  override async *_streamResponseChunks(
+    messages: BaseMessage[],
+    options: this['ParsedCallOptions'],
+    runManager?: CallbackManagerForLLMRun,
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const messagesMapped = attachReasoningContentToCompletionsMessages(
+      convertMessagesToCompletionsMessageParams({
+        messages,
+        model: this.model,
+      }),
+      messages,
+    )
+    const params = {
+      ...this.invocationParams(options, { streaming: true }),
+      messages: messagesMapped,
+      stream: true,
+    } satisfies OpenAIClient.Chat.Completions.ChatCompletionCreateParamsStreaming
+    let defaultRole: OpenAIClient.Chat.ChatCompletionRole | undefined
+    const streamIterable = await this.completionWithRetry(params, options)
+    let usage: OpenAIClient.Completions.CompletionUsage | undefined
+    for await (const data of streamIterable) {
+      if (options.signal?.aborted) return
+      const choice = data?.choices?.[0]
+      if (data.usage) usage = data.usage
+      if (!choice) continue
+      const { delta } = choice
+      if (!delta) continue
+      const chunk = this._convertCompletionsDeltaToBaseMessageChunk(delta as unknown as Record<string, unknown>, data, defaultRole)
+      defaultRole = delta.role ?? defaultRole
+      const newTokenIndices = {
+        prompt: options.promptIndex ?? 0,
+        completion: choice.index ?? 0,
+      }
+      if (typeof chunk.content !== 'string') {
+        continue
+      }
+      const generationInfo: Record<string, unknown> = { ...newTokenIndices }
+      if (choice.finish_reason != null) {
+        generationInfo.finish_reason = choice.finish_reason
+        generationInfo.system_fingerprint = data.system_fingerprint
+        generationInfo.model_name = data.model
+        generationInfo.service_tier = data.service_tier
+      }
+      if (this.logprobs) generationInfo.logprobs = choice.logprobs
+      const generationChunk = new ChatGenerationChunk({
+        message: chunk,
+        text: chunk.content,
+        generationInfo,
+      })
+      yield generationChunk
+      await runManager?.handleLLMNewToken(generationChunk.text ?? '', newTokenIndices, undefined, undefined, undefined, {
+        chunk: generationChunk,
+      })
+    }
+    if (usage) {
+      const inputTokenDetails = {
+        ...(usage.prompt_tokens_details?.audio_tokens !== null && { audio: usage.prompt_tokens_details?.audio_tokens }),
+        ...(usage.prompt_tokens_details?.cached_tokens !== null && { cache_read: usage.prompt_tokens_details?.cached_tokens }),
+      }
+      const outputTokenDetails = {
+        ...(usage.completion_tokens_details?.audio_tokens !== null && { audio: usage.completion_tokens_details?.audio_tokens }),
+        ...(usage.completion_tokens_details?.reasoning_tokens !== null && { reasoning: usage.completion_tokens_details?.reasoning_tokens }),
+      }
+      yield new ChatGenerationChunk({
+        message: new AIMessageChunk({
+          content: '',
+          response_metadata: { usage: { ...usage } },
+          usage_metadata: {
+            input_tokens: usage.prompt_tokens,
+            output_tokens: usage.completion_tokens,
+            total_tokens: usage.total_tokens,
+            ...(Object.keys(inputTokenDetails).length > 0 && { input_token_details: inputTokenDetails }),
+            ...(Object.keys(outputTokenDetails).length > 0 && { output_token_details: outputTokenDetails }),
+          },
+        }),
+        text: '',
+      })
+    }
+    if (options.signal?.aborted) throw new Error('AbortError')
+  }
+
+  protected override _convertCompletionsDeltaToBaseMessageChunk(
+    delta: Record<string, unknown>,
+    rawResponse: OpenAIClient.Chat.Completions.ChatCompletionChunk,
+    defaultRole?: OpenAIClient.Chat.ChatCompletionRole,
+  ): BaseMessageChunk {
+    return mergeReasoningContentIntoMessage(
+      super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole),
+      delta,
+    )
+  }
+
+  protected override _convertCompletionsMessageToBaseMessage(
+    message: OpenAIClient.ChatCompletionMessage,
+    rawResponse: OpenAIClient.ChatCompletion,
+  ): BaseMessage {
+    return mergeReasoningContentIntoMessage(
+      super._convertCompletionsMessageToBaseMessage(message, rawResponse),
+      message as unknown as Record<string, unknown>,
+    )
+  }
+}
+
+export function createDeepSeekReasoningChatOpenAI(fields: ChatOpenAIFields): ChatOpenAI {
+  return new ChatOpenAI({
+    ...fields,
+    completions: new DeepSeekReasoningChatOpenAICompletions(fields),
+  })
+}

package/src/lib/providers/openai.test.ts

@@ -1,7 +1,12 @@
 import assert from 'node:assert/strict'
 import test from 'node:test'
 
+import { AIMessage } from '@langchain/core/messages'
 import { streamOpenAiChat } from './openai'
+import {
+  attachReasoningContentToCompletionsMessages,
+  getReasoningContentFromLangChainMessage,
+} from './deepseek-reasoning-chat-openai'
 
 function sseChunk(data: unknown) {
   return `data: ${JSON.stringify(data)}\n\n`
@@ -44,11 +49,78 @@ test('OpenAI-compatible reasoning deltas stream as thinking instead of visible t
     } as Parameters<typeof streamOpenAiChat>[0])
 
     assert.equal(result, 'visible answer')
-    assert.deepEqual(parseSseEvents(writes), [
+    const events = parseSseEvents(writes)
+    assert.deepEqual(events, [
       { t: 'thinking', text: 'internal reasoning ' },
+      { t: 'md', text: JSON.stringify({ reasoningContentDelta: 'internal reasoning ' }) },
       { t: 'd', text: 'visible answer' },
     ])
   } finally {
     globalThis.fetch = originalFetch
   }
 })
+
+test('OpenAI-compatible DeepSeek history replays stored assistant reasoning_content', async () => {
+  const originalFetch = globalThis.fetch
+  const encoded = new TextEncoder()
+  const frames = [
+    sseChunk({ choices: [{ delta: { content: 'next answer' } }] }),
+    'data: [DONE]\n\n',
+  ]
+  const writes: string[] = []
+  const capture: { requestBody?: { messages?: Array<Record<string, unknown>> } } = {}
+
+  globalThis.fetch = async (_url, init) => {
+    capture.requestBody = JSON.parse(String(init?.body || '{}')) as { messages?: Array<Record<string, unknown>> }
+    return new Response(new ReadableStream({
+      start(controller) {
+        for (const frame of frames) controller.enqueue(encoded.encode(frame))
+        controller.close()
+      },
+    }), {
+      status: 200,
+      headers: { 'content-type': 'text/event-stream' },
+    })
+  }
+
+  try {
+    await streamOpenAiChat({
+      session: {
+        id: 'session-1',
+        provider: 'deepseek',
+        model: 'deepseek-reasoner',
+        apiEndpoint: 'https://api.deepseek.com/v1',
+      },
+      message: 'next',
+      write: (data) => writes.push(data),
+      active: new Map(),
+      loadHistory: () => [{
+        role: 'assistant',
+        text: 'visible answer',
+        reasoningContent: 'hidden chain',
+      }],
+    } as Parameters<typeof streamOpenAiChat>[0])
+
+    const messages = capture.requestBody?.messages
+    assert.deepEqual(messages, [
+      { role: 'assistant', content: 'visible answer', reasoning_content: 'hidden chain' },
+      { role: 'user', content: 'next' },
+    ])
+  } finally {
+    globalThis.fetch = originalFetch
+  }
+})
+
+test('DeepSeek reasoning helper preserves native reasoning for LangChain replay', () => {
+  const assistant = new AIMessage({
+    content: 'visible answer',
+    additional_kwargs: { reasoning_content: 'hidden chain' },
+  })
+
+  assert.equal(getReasoningContentFromLangChainMessage(assistant), 'hidden chain')
+  assert.deepEqual(attachReasoningContentToCompletionsMessages([
+    { role: 'assistant', content: 'visible answer' },
+  ], [assistant]), [
+    { role: 'assistant', content: 'visible answer', reasoning_content: 'hidden chain' },
+  ])
+})

package/src/lib/providers/openai.ts

@@ -3,6 +3,10 @@ import type { StreamChatOptions } from './index'
 import { PROVIDER_DEFAULTS, IMAGE_EXTS, TEXT_EXTS, PDF_MAX_CHARS, MAX_HISTORY_MESSAGES, writeSSE } from './provider-defaults'
 import { log } from '@/lib/server/logger'
 import { resolveImagePath } from '@/lib/server/resolve-image'
+import {
+  createReasoningContentMetadata,
+  shouldUseDeepSeekReasoningBridge,
+} from '@/lib/providers/deepseek-reasoning-chat-openai'
 
 const TAG = 'provider-openai'
 
@@ -173,6 +177,7 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
                       : ''
                 if (reasoningDelta) {
                   writeSSE(write, 'thinking', reasoningDelta)
+                  writeSSE(write, 'md', JSON.stringify(createReasoningContentMetadata(reasoningDelta)))
                 }
                 if (contentDelta) {
                   fullResponse += contentDelta
@@ -217,7 +222,11 @@ export function streamOpenAiChat({ session, message, imagePath, imageUrl, apiKey
 }
 
 async function buildMessages(session: Record<string, unknown>, message: string, imagePath: string | undefined, systemPrompt: string | undefined, loadHistory: (id: string) => Record<string, unknown>[], imageUrl?: string) {
-  const msgs: Array<{ role: string; content: unknown }> = []
+  const msgs: Array<{ role: string; content: unknown; reasoning_content?: string }> = []
+  const includeReasoningContent = shouldUseDeepSeekReasoningBridge(
+    typeof session.provider === 'string' ? session.provider : null,
+    typeof session.apiEndpoint === 'string' ? session.apiEndpoint : null,
+  )
 
   if (systemPrompt) {
     msgs.push({ role: 'system', content: systemPrompt })
@@ -231,7 +240,15 @@ async function buildMessages(session: Record<string, unknown>, message: string,
         const parts = await fileToContentParts(histImagePath)
         msgs.push({ role: 'user', content: [...parts, { type: 'text', text: m.text }] })
       } else {
-        msgs.push({ role: m.role as string, content: m.text })
+        const role = m.role as string
+        const reasoningContent = includeReasoningContent && role === 'assistant' && typeof m.reasoningContent === 'string'
+          ? m.reasoningContent
+          : ''
+        msgs.push({
+          role,
+          content: m.text,
+          ...(reasoningContent ? { reasoning_content: reasoningContent } : {}),
+        })
       }
     }
   }

package/src/lib/server/build-llm.test.ts

@@ -250,6 +250,19 @@ test('buildChatModel disables parallel_tool_calls for Ollama local to avoid dupl
   assert.equal(llm.clientConfig?.baseURL, 'http://localhost:11434/v1')
 })
 
+test('buildChatModel uses a reasoning_content-preserving bridge for DeepSeek', () => {
+  const llm = buildChatModel({
+    provider: 'deepseek',
+    model: 'deepseek-reasoner',
+    apiKey: 'deepseek-key',
+  }) as ChatOpenAI
+  const completionBridge = llm as unknown as { completions?: { constructor?: { name?: string } } }
+
+  assert.equal(llm.model, 'deepseek-reasoner')
+  assert.equal(llm.clientConfig?.baseURL, 'https://api.deepseek.com/v1')
+  assert.equal(completionBridge.completions?.constructor?.name, 'DeepSeekReasoningChatOpenAICompletions')
+})
+
 test('buildChatModel uses Ollama Cloud only when explicit cloud mode is selected', () => {
   saveCredentials({
     'cred-1': {

package/src/lib/server/build-llm.ts

@@ -2,6 +2,10 @@ import { ChatAnthropic } from '@langchain/anthropic'
 import { ChatOpenAI } from '@langchain/openai'
 import { getProviderList } from '../providers'
 import { normalizeOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
+import {
+  createDeepSeekReasoningChatOpenAI,
+  shouldUseDeepSeekReasoningBridge,
+} from '@/lib/providers/deepseek-reasoning-chat-openai'
 import { NON_LANGGRAPH_PROVIDER_IDS } from '../provider-sets'
 import { resolveOllamaRuntimeConfig } from './ollama-runtime'
 import { resolveProviderApiEndpoint, resolveProviderCredentialId } from './provider-endpoint'
@@ -136,6 +140,9 @@ export function buildChatModel(opts: {
       config.configuration.defaultHeaders = { 'Content-Type': 'text/plain' }
     }
   }
+  if (shouldUseDeepSeekReasoningBridge(provider, endpoint)) {
+    return createDeepSeekReasoningChatOpenAI(config)
+  }
   return new ChatOpenAI(config)
 }
 

package/src/lib/server/chat-execution/chat-turn-finalization.ts

@@ -278,6 +278,7 @@ export async function finalizeChatTurn(params: {
 
   const {
     thinkingText,
+    reasoningContent,
     streamErrors,
     accumulatedUsage,
   } = partialPersistence.getSnapshot()
@@ -487,6 +488,7 @@ export async function finalizeChatTurn(params: {
           text: persistedText,
           time: nowTs,
           thinking: thinkingText || undefined,
+          reasoningContent: reasoningContent || undefined,
           toolEvents: persistedToolEvents.length ? persistedToolEvents : undefined,
           kind: persistedKind,
           citations: grounding.citations.length > 0 ? grounding.citations : undefined,

package/src/lib/server/chat-execution/chat-turn-partial-persistence.ts

@@ -19,9 +19,11 @@ import {
   applyMessageLifecycleHooks,
   type PreparedExecutableChatTurn,
 } from '@/lib/server/chat-execution/chat-turn-preparation'
+import { REASONING_CONTENT_MD_KEY } from '@/lib/providers/deepseek-reasoning-chat-openai'
 
 export interface PartialAssistantSnapshot {
   thinkingText: string
+  reasoningContent: string
   toolEvents: MessageToolEvent[]
   streamErrors: string[]
   accumulatedUsage: {
@@ -53,6 +55,7 @@ export function createPartialAssistantPersistence(input: {
   const accumulatedUsage = { inputTokens: 0, outputTokens: 0, estimatedCost: 0 }
 
   let thinkingText = ''
+  let reasoningContent = ''
   let streamingPartialText = ''
   let lastPartialSaveAt = 0
   let lastPartialSnapshotKey = ''
@@ -82,6 +85,7 @@ export function createPartialAssistantPersistence(input: {
           streaming: true,
           runId: prepared.lifecycleRunId,
           thinking: thinkingText || undefined,
+          reasoningContent: reasoningContent || undefined,
           toolEvents: persistedToolEvents.length ? persistedToolEvents : undefined,
         },
         enabledIds: prepared.extensionsForRun,
@@ -93,6 +97,7 @@ export function createPartialAssistantPersistence(input: {
       const snapshotKey = JSON.stringify([
         partialMsg.text,
         partialMsg.thinking || '',
+        partialMsg.reasoningContent || '',
         getToolEventsSnapshotKey(partialMsg.toolEvents || []),
       ])
       if (snapshotKey === lastPartialSnapshotKey) return
@@ -140,6 +145,7 @@ export function createPartialAssistantPersistence(input: {
     if (event.t === 'reset') {
       streamingPartialText = event.text || ''
       thinkingText = ''
+      reasoningContent = ''
       toolEvents.length = 0
       shouldPersistPartial = true
       immediatePartialPersist = true
@@ -169,6 +175,11 @@ export function createPartialAssistantPersistence(input: {
           if (typeof usage.outputTokens === 'number') accumulatedUsage.outputTokens += usage.outputTokens
           if (typeof usage.estimatedCost === 'number') accumulatedUsage.estimatedCost += usage.estimatedCost
         }
+        const reasoningContentDelta = mdPayload[REASONING_CONTENT_MD_KEY]
+        if (typeof reasoningContentDelta === 'string' && reasoningContentDelta.length > 0) {
+          reasoningContent += reasoningContentDelta
+          shouldPersistPartial = true
+        }
       } catch {
         // Ignore non-JSON md events.
       }
@@ -212,6 +223,7 @@ export function createPartialAssistantPersistence(input: {
     getSnapshot() {
       return {
         thinkingText,
+        reasoningContent,
         toolEvents: [...toolEvents],
         streamErrors: [...streamErrors],
         accumulatedUsage: { ...accumulatedUsage },

package/src/lib/server/chat-execution/iteration-event-handler.ts

@@ -26,6 +26,10 @@ import { truncateToolResultText, calculateMaxToolResultChars } from '@/lib/serve
 import { notifyWithPayload } from '@/lib/server/ws-hub'
 import { resolveExclusiveMemoryWriteTerminalAllowance } from '@/lib/server/chat-execution/chat-streaming-utils'
 import { getContextWindowSize } from '@/lib/server/context-manager'
+import {
+  createReasoningContentMetadata,
+  extractReasoningContentDelta,
+} from '@/lib/providers/deepseek-reasoning-chat-openai'
 
 // ---------------------------------------------------------------------------
 // LangGraph event kind constants
@@ -82,7 +86,7 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
   } = opts
 
   let waitingForToolResult = false
-  let reachedExecutionBoundary = false
+  const reachedExecutionBoundary = false
   let executionFollowthroughReason: 'research_limit' | 'post_simulation' | null = null
   let loopBroken = false
   let toolEndCount = 0
@@ -98,6 +102,12 @@ export async function processIterationEvents(opts: ProcessIterationEventsOpts):
     if (kind === EVENT_CHAT_MODEL_STREAM) {
       timers.armIdleWatchdog(waitingForToolResult)
       const chunk = event.data?.chunk
+      const reasoningDelta = extractReasoningContentDelta(chunk?.additional_kwargs as Record<string, unknown> | undefined)
+      if (reasoningDelta) {
+        state.accumulatedThinking += reasoningDelta
+        write(`data: ${JSON.stringify({ t: 'thinking', text: reasoningDelta })}\n\n`)
+        write(`data: ${JSON.stringify({ t: 'md', text: JSON.stringify(createReasoningContentMetadata(reasoningDelta)) })}\n\n`)
+      }
       if (chunk?.content) {
         if (Array.isArray(chunk.content)) {
           for (const block of chunk.content) {

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -171,6 +171,15 @@ function extractProviderErrorInfo(err: unknown): { statusCode: number; retryAfte
   return { statusCode, retryAfterMs }
 }
 
+function buildAssistantHistoryMessage(message: Message): AIMessage {
+  return new AIMessage({
+    content: message.text,
+    ...(message.reasoningContent
+      ? { additional_kwargs: { reasoning_content: message.reasoningContent } }
+      : {}),
+  })
+}
+
 /** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
 interface StreamAgentChatOpts {
   session: Session
@@ -732,7 +741,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       const resolvedImg = resolveImagePath(m.imagePath, m.imageUrl)
       langchainMessages.push(new HumanMessage({ content: await buildLangChainContent(m.text, resolvedImg ?? undefined, m.attachedFiles) }))
     } else {
-      langchainMessages.push(new AIMessage({ content: m.text }))
+      langchainMessages.push(buildAssistantHistoryMessage(m))
     }
   }
 
@@ -1085,7 +1094,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
             if (m.role === 'user') {
               langchainMessages.push(new HumanMessage({ content: m.text }))
             } else {
-              langchainMessages.push(new AIMessage({ content: m.text }))
+              langchainMessages.push(buildAssistantHistoryMessage(m))
             }
           }
           langchainMessages.push(new HumanMessage({ content: currentContent }))

package/src/types/message.ts

@@ -40,6 +40,8 @@ export interface Message {
   attachedFiles?: string[]
   toolEvents?: MessageToolEvent[]
   thinking?: string
+  /** Provider-native assistant reasoning used only when replaying model history. */
+  reasoningContent?: string
   kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear' | 'extension-ui' | 'connector-delivery'
   suppressed?: boolean
   bookmarked?: boolean