Preserve Moonshot Kimi reasoning history

Author: jahooma

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

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'bun:test'
+
+import { buildMoonshotRequestBody } from '../moonshot'
+
+import type { ChatCompletionRequestBody } from '../types'
+
+type MoonshotRequestBody = Omit<ChatCompletionRequestBody, 'messages'> & {
+  messages: Array<
+    ChatCompletionRequestBody['messages'][number] & {
+      reasoning_content?: string | null
+    }
+  >
+}
+
+function buildBody(body: MoonshotRequestBody) {
+  return buildMoonshotRequestBody(
+    body as ChatCompletionRequestBody,
+    'moonshotai/kimi-k2.6',
+  )
+}
+
+describe('buildMoonshotRequestBody', () => {
+  it('enables preserved thinking by default for Kimi K2.6', () => {
+    const body = buildBody({
+      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.',
+        },
+      ],
+    })
+
+    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 = buildBody({
+      model: 'moonshotai/kimi-k2.6',
+      messages: [{ role: 'user', content: 'hello' }],
+      reasoning: { enabled: true },
+    })
+
+    expect(body.thinking).toEqual({ type: 'enabled', keep: 'all' })
+    expect(body.reasoning).toBeUndefined()
+  })
+
+  it('does not preserve thinking when reasoning is explicitly disabled', () => {
+    const body = buildBody({
+      model: 'moonshotai/kimi-k2.6',
+      messages: [
+        {
+          role: 'assistant',
+          content: 'Done.',
+          reasoning_content: 'Used the tool result.',
+        },
+        { role: 'user', content: 'next' },
+      ],
+      reasoning: { enabled: false },
+    })
+
+    expect(body.thinking).toEqual({ type: 'disabled' })
+    expect(body.reasoning).toBeUndefined()
+  })
+})

web/src/llm-api/moonshot.ts

@@ -59,6 +59,11 @@ type LineResult = {
   patchedLine: string
 }
 
+type MoonshotChatMessage = ChatCompletionRequestBody['messages'][number] & {
+  cache_control?: unknown
+  reasoning_content?: string | null
+}
+
 export function isMoonshotModel(model: unknown): model is string {
   return typeof model === 'string' && model in MOONSHOT_MODEL_MAP
 }
@@ -89,6 +94,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 +120,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,29 +133,44 @@ 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(
   messages: ChatCompletionRequestBody['messages'],
-): ChatCompletionRequestBody['messages'] {
+): MoonshotChatMessage[] {
   return messages.map((message) => {
     const {
       cache_control: _cacheControl,
       content,
       ...rest
-    } = message as typeof message & {
-      cache_control?: unknown
-    }
+    } = message as MoonshotChatMessage
     return {
       ...rest,
       ...(content !== undefined && {