Preserve Moonshot Kimi reasoning history

Author: jahooma

web/src/llm-api/__tests__/moonshot.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'bun:test'
+
+import { buildMoonshotRequestBody } from '../moonshot'
+
+describe('buildMoonshotRequestBody', () => {
+  it('enables preserved thinking by default for Kimi K2.6', () => {
+    const body = buildMoonshotRequestBody(
+      {
+        model: 'moonshotai/kimi-k2.6',
+        messages: [
+          {
+            role: 'assistant',
+            content: 'I will inspect the files.',
+            reasoning_content: 'Need to understand the repo first.',
+          },
+          {
+            role: 'user',
+            content: 'Continue.',
+          },
+        ],
+      },
+      'moonshotai/kimi-k2.6',
+    )
+
+    expect(body.model).toBe('kimi-k2.6')
+    expect(body.thinking).toEqual({ type: 'enabled', keep: 'all' })
+    expect(body.messages).toEqual([
+      {
+        role: 'assistant',
+        content: 'I will inspect the files.',
+        reasoning_content: 'Need to understand the repo first.',
+      },
+      {
+        role: 'user',
+        content: 'Continue.',
+      },
+    ])
+  })
+
+  it('keeps historical reasoning when thinking is explicitly enabled', () => {
+    const body = buildMoonshotRequestBody(
+      {
+        model: 'moonshotai/kimi-k2.6',
+        messages: [{ role: 'user', content: 'hello' }],
+        reasoning: { enabled: true },
+      },
+      'moonshotai/kimi-k2.6',
+    )
+
+    expect(body.thinking).toEqual({ type: 'enabled', keep: 'all' })
+    expect(body.reasoning).toBeUndefined()
+  })
+
+  it('does not preserve thinking when reasoning is explicitly disabled', () => {
+    const body = buildMoonshotRequestBody(
+      {
+        model: 'moonshotai/kimi-k2.6',
+        messages: [
+          {
+            role: 'assistant',
+            content: 'Done.',
+            reasoning_content: 'Used the tool result.',
+          },
+          { role: 'user', content: 'next' },
+        ],
+        reasoning: { enabled: false },
+      },
+      'moonshotai/kimi-k2.6',
+    )
+
+    expect(body.thinking).toEqual({ type: 'disabled' })
+    expect(body.reasoning).toBeUndefined()
+  })
+})

web/src/llm-api/moonshot.ts

@@ -89,6 +89,24 @@ function createMoonshotRequest(params: {
   fetch: typeof globalThis.fetch
 }) {
   const { body, originalModel, fetch } = params
+  const moonshotBody = buildMoonshotRequestBody(body, originalModel)
+
+  return fetch(`${MOONSHOT_BASE_URL}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${getMoonshotApiKey()}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(moonshotBody),
+    // @ts-expect-error - dispatcher is a valid undici option not in fetch types
+    dispatcher: moonshotAgent,
+  })
+}
+
+export function buildMoonshotRequestBody(
+  body: ChatCompletionRequestBody,
+  originalModel: string,
+): Record<string, unknown> {
   const moonshotCompatibleBody = addKimiToolCompatibilityFields(body)
   const moonshotBody: Record<string, unknown> = {
     ...moonshotCompatibleBody,
@@ -97,12 +115,7 @@ function createMoonshotRequest(params: {
     model: getMoonshotModelId(originalModel),
   }
 
-  if (moonshotBody.reasoning && typeof moonshotBody.reasoning === 'object') {
-    const reasoning = moonshotBody.reasoning as { enabled?: boolean }
-    moonshotBody.thinking = {
-      type: reasoning.enabled === false ? 'disabled' : 'enabled',
-    }
-  }
+  moonshotBody.thinking = createMoonshotThinking(moonshotBody)
 
   delete moonshotBody.reasoning
   delete moonshotBody.reasoning_effort
@@ -115,16 +128,33 @@ function createMoonshotRequest(params: {
     moonshotBody.stream_options = { include_usage: true }
   }
 
-  return fetch(`${MOONSHOT_BASE_URL}/chat/completions`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${getMoonshotApiKey()}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(moonshotBody),
-    // @ts-expect-error - dispatcher is a valid undici option not in fetch types
-    dispatcher: moonshotAgent,
-  })
+  return moonshotBody
+}
+
+function createMoonshotThinking(
+  moonshotBody: Record<string, unknown>,
+): Record<string, unknown> {
+  const reasoning =
+    moonshotBody.reasoning && typeof moonshotBody.reasoning === 'object'
+      ? (moonshotBody.reasoning as { enabled?: boolean })
+      : undefined
+  if (reasoning?.enabled === false) {
+    return { type: 'disabled' }
+  }
+
+  const existingThinking =
+    moonshotBody.thinking && typeof moonshotBody.thinking === 'object'
+      ? (moonshotBody.thinking as Record<string, unknown>)
+      : {}
+  if (existingThinking.type === 'disabled') {
+    return { type: 'disabled' }
+  }
+
+  return {
+    ...existingThinking,
+    type: 'enabled',
+    keep: 'all',
+  }
 }
 
 function normalizeMoonshotMessages(

web/src/llm-api/types.ts

@@ -16,6 +16,8 @@ export interface CodebuffMetadata {
 export interface ChatMessage {
   role: 'system' | 'user' | 'assistant' | 'tool'
   content?: string | ChatCompletionContentPart[] | null
+  reasoning_content?: string | null
+  reasoning?: string | null
   name?: string
   tool_calls?: Array<{
     id: string