fix(moonshot): preserve Kimi K3 behavior on the OpenAI SDK handler path

- Honor requiredReasoningEffort in getOpenAiReasoning so Kimi K3 always
  sends reasoning_effort=max, matching the Roo provider precedent
- Send resolved reasoning params in completePrompt and the non-streaming
  createMessage branch
- Skip explicit cache_control breakpoints for Moonshot (automatic caching)
  via a useExplicitCacheBreakpoints hook
- Rewrite the K3 moonshot specs for the OpenAI SDK handler path and add
  coverage for required-effort resolution and the non-streaming branch

Author: roomote

src/api/providers/__tests__/moonshot.spec.ts

@@ -1,5 +1,4 @@
 import type { Anthropic } from "@anthropic-ai/sdk"
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
 
 import { moonshotDefaultModelId } from "@roo-code/types"
 
@@ -168,14 +167,20 @@ describe("MoonshotHandler", () => {
 		})
 
 		it("omits temperature and sends required max reasoning for Kimi K3", async () => {
-			async function* mockFullStream() {
-				yield { type: "text-delta", text: "K3 response" }
+			async function* mockStream() {
+				yield {
+					choices: [{ delta: { content: "K3 response" }, finish_reason: null }],
+					usage: null,
+				}
 			}
 
-			mockStreamText.mockReturnValue({
-				fullStream: mockFullStream(),
-				usage: Promise.resolve({ inputTokens: 1, outputTokens: 1, details: {}, raw: {} }),
-			})
+			const mockClient = {
+				chat: {
+					completions: {
+						create: vi.fn().mockResolvedValue(mockStream()),
+					},
+				},
+			}
 
 			const k3Handler = new MoonshotHandler({
 				...mockOptions,
@@ -184,26 +189,57 @@ describe("MoonshotHandler", () => {
 				reasoningEffort: "disable",
 				enableReasoningEffort: false,
 			})
+			;(k3Handler as any).client = mockClient
+
 			for await (const _chunk of k3Handler.createMessage(systemPrompt, messages)) {
 				void _chunk
 			}
 
-			expect(mockStreamText).toHaveBeenCalledWith(
-				expect.objectContaining({
-					temperature: undefined,
-					maxOutputTokens: 131_072,
-					providerOptions: { openaiCompatible: { reasoningEffort: "max" } },
-				}),
-			)
+			const [requestOptions] = mockClient.chat.completions.create.mock.calls[0]
+			expect(requestOptions).toMatchObject({
+				model: "kimi-k3",
+				reasoning_effort: "max",
+				max_tokens: 131_072,
+			})
+			expect(requestOptions).not.toHaveProperty("temperature")
 		})
 
-		it("serializes retained Kimi K3 reasoning through the installed AI SDK", async () => {
-			const actualAi = await vi.importActual<typeof import("ai")>("ai")
-			const actualOpenAICompatible =
-				await vi.importActual<typeof import("@ai-sdk/openai-compatible")>("@ai-sdk/openai-compatible")
-			vi.mocked(createOpenAICompatible).mockImplementationOnce(actualOpenAICompatible.createOpenAICompatible)
-			mockStreamText.mockImplementationOnce(actualAi.streamText)
+		it("sends required max reasoning for Kimi K3 when streaming is disabled", async () => {
+			const mockClient = {
+				chat: {
+					completions: {
+						create: vi.fn().mockResolvedValue({
+							choices: [{ message: { content: "K3 response" } }],
+							usage: { prompt_tokens: 1, completion_tokens: 1 },
+						}),
+					},
+				},
+			}
 
+			const k3Handler = new MoonshotHandler({
+				...mockOptions,
+				apiModelId: "kimi-k3",
+				modelTemperature: 0.9,
+				reasoningEffort: "disable",
+				enableReasoningEffort: false,
+				openAiStreamingEnabled: false,
+			})
+			;(k3Handler as any).client = mockClient
+
+			for await (const _chunk of k3Handler.createMessage(systemPrompt, messages)) {
+				void _chunk
+			}
+
+			const [requestOptions] = mockClient.chat.completions.create.mock.calls[0]
+			expect(requestOptions).toMatchObject({
+				model: "kimi-k3",
+				reasoning_effort: "max",
+				max_tokens: 131_072,
+			})
+			expect(requestOptions).not.toHaveProperty("temperature")
+		})
+
+		it("serializes retained Kimi K3 reasoning through the installed OpenAI SDK", async () => {
 			let requestBody: Record<string, any> | undefined
 			const fetchMock = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
 				requestBody = JSON.parse(String(init?.body))
@@ -236,24 +272,20 @@ describe("MoonshotHandler", () => {
 					},
 				] as Anthropic.Messages.MessageParam[]
 
-				try {
-					for await (const _chunk of k3Handler.createMessage("system", retainedMessages)) {
-						// Drain the stream so the installed SDK serializes the HTTP request.
-					}
-				} catch (error) {
-					// The synthetic SSE only needs to support request serialization.
-					expect((error as Error).name).toBe("AI_NoOutputGeneratedError")
+				for await (const _chunk of k3Handler.createMessage("system", retainedMessages)) {
+					void _chunk
 				}
 
 				expect(requestBody).toMatchObject({
 					model: "kimi-k3",
 					reasoning_effort: "max",
+					max_tokens: 131_072,
 					messages: [
 						{ role: "system", content: "system" },
 						{ role: "user", content: "Inspect the file" },
 						{
 							role: "assistant",
-							content: null,
+							content: "",
 							reasoning_content: "I need the file contents first.",
 							tool_calls: [
 								{
@@ -365,24 +397,35 @@ describe("MoonshotHandler", () => {
 		})
 
 		it("omits temperature and sends required max reasoning for Kimi K3", async () => {
-			mockGenerateText.mockResolvedValue({ text: "K3 completion" })
+			const mockClient = {
+				chat: {
+					completions: {
+						create: vi.fn().mockResolvedValue({
+							choices: [{ message: { content: "K3 completion" } }],
+						}),
+					},
+				},
+			}
+
 			const k3Handler = new MoonshotHandler({
 				...mockOptions,
 				apiModelId: "kimi-k3",
 				modelTemperature: 0.9,
 				reasoningEffort: "disable",
 				enableReasoningEffort: false,
 			})
+			;(k3Handler as any).client = mockClient
 
-			await k3Handler.completePrompt("Test prompt")
+			const result = await k3Handler.completePrompt("Test prompt")
 
-			expect(mockGenerateText).toHaveBeenCalledWith(
-				expect.objectContaining({
-					temperature: undefined,
-					maxOutputTokens: 131_072,
-					providerOptions: { openaiCompatible: { reasoningEffort: "max" } },
-				}),
-			)
+			expect(result).toBe("K3 completion")
+			const [requestOptions] = mockClient.chat.completions.create.mock.calls[0]
+			expect(requestOptions).toMatchObject({
+				model: "kimi-k3",
+				reasoning_effort: "max",
+				max_tokens: 131_072,
+			})
+			expect(requestOptions).not.toHaveProperty("temperature")
 		})
 	})
 

src/api/providers/moonshot.ts

@@ -72,6 +72,14 @@ export class MoonshotHandler extends OpenAiHandler {
 		}
 	}
 
+	/**
+	 * Moonshot caches prompts automatically; explicit Anthropic-style
+	 * cache_control breakpoints are not part of its OpenAI-compatible API.
+	 */
+	protected override useExplicitCacheBreakpoints(): boolean {
+		return false
+	}
+
 	/**
 	 * Override to always include max_tokens for Moonshot (not max_completion_tokens).
 	 * Moonshot requires max_tokens parameter to be sent.

src/api/providers/openai.ts

@@ -105,7 +105,7 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 			if (deepseekReasoner) {
 				convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 			} else {
-				if (modelInfo.supportsPromptCache) {
+				if (modelInfo.supportsPromptCache && this.useExplicitCacheBreakpoints()) {
 					systemMessage = {
 						role: "system",
 						content: [
@@ -121,7 +121,7 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 
 				convertedMessages = [systemMessage, ...convertToOpenAiMessages(messages)]
 
-				if (modelInfo.supportsPromptCache) {
+				if (modelInfo.supportsPromptCache && this.useExplicitCacheBreakpoints()) {
 					// Note: the following logic is copied from openrouter:
 					// Add cache_control to the last two user messages
 					// (note: this works because we only ever add one user message at a time, but if we added multiple we'd need to mark the user message before the last assistant message)
@@ -230,6 +230,9 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 				messages: deepseekReasoner
 					? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
 					: [systemMessage, ...convertToOpenAiMessages(messages)],
+				// Send reasoning params when the model resolves them (e.g. models that
+				// require reasoning effort), matching the streaming path.
+				...(reasoning && reasoning),
 				// Tools are always present (minimum ALWAYS_AVAILABLE_TOOLS)
 				tools: this.convertToolsForOpenAI(metadata?.tools),
 				tool_choice: metadata?.tool_choice,
@@ -273,6 +276,16 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 		}
 	}
 
+	/**
+	 * Whether to attach explicit Anthropic-style cache_control breakpoints to
+	 * requests. Providers whose prompt caching is automatic (e.g. Moonshot)
+	 * override this to skip breakpoints their OpenAI-compatible endpoints do
+	 * not support.
+	 */
+	protected useExplicitCacheBreakpoints(): boolean {
+		return true
+	}
+
 	protected processUsageMetrics(usage: any, _modelInfo?: ModelInfo): ApiStreamUsageChunk {
 		return {
 			type: "usage",
@@ -305,6 +318,9 @@ export class OpenAiHandler extends BaseProvider implements SingleCompletionHandl
 			const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
 				model: model.id,
 				messages: [{ role: "user", content: prompt }],
+				// Send reasoning params when the model resolves them (e.g. models that
+				// require reasoning effort), matching the streaming path.
+				...(model.reasoning && model.reasoning),
 			}
 
 			// Add max_tokens if needed

src/api/transform/__tests__/reasoning.spec.ts

@@ -547,6 +547,52 @@ describe("reasoning.ts", () => {
 			expect(result).toEqual({ reasoning_effort: "medium" })
 		})
 
+		it("should send the model's required effort even when the user disables reasoning", () => {
+			const requiredModel: ModelInfo = {
+				...baseModel,
+				supportsReasoningEffort: ["max"],
+				requiredReasoningEffort: true,
+				reasoningEffort: "max",
+			}
+
+			const options = {
+				...baseOptions,
+				model: requiredModel,
+				reasoningEffort: "disable" as const,
+				settings: { reasoningEffort: "disable", enableReasoningEffort: false } as ProviderSettings,
+			}
+
+			const result = getOpenAiReasoning(options)
+
+			expect(result).toEqual({ reasoning_effort: "max" })
+		})
+
+		it("should send the model's required effort with default settings", () => {
+			const requiredModel: ModelInfo = {
+				...baseModel,
+				supportsReasoningEffort: ["max"],
+				requiredReasoningEffort: true,
+				reasoningEffort: "max",
+			}
+
+			const options = { ...baseOptions, model: requiredModel }
+
+			const result = getOpenAiReasoning(options)
+
+			expect(result).toEqual({ reasoning_effort: "max" })
+		})
+
+		it("should fall back to normal handling when requiredReasoningEffort has no model effort", () => {
+			const requiredWithoutEffort: ModelInfo = {
+				...baseModel,
+				requiredReasoningEffort: true,
+			}
+
+			const result = getOpenAiReasoning({ ...baseOptions, model: requiredWithoutEffort, settings: {} })
+
+			expect(result).toBeUndefined()
+		})
+
 		it("should return undefined when model has no reasoning effort capability", () => {
 			const result = getOpenAiReasoning(baseOptions)
 			expect(result).toBeUndefined()

src/api/transform/reasoning.ts

@@ -129,6 +129,15 @@ export const getOpenAiReasoning = ({
 	reasoningEffort,
 	settings,
 }: GetModelReasoningOptions): OpenAiReasoningParams | undefined => {
+	// Models that require reasoning effort always send the model's effort,
+	// regardless of user toggles (mirrors the required-effort handling in
+	// getRooReasoning and the gateway providers).
+	if (model.requiredReasoningEffort && model.reasoningEffort) {
+		return {
+			reasoning_effort: model.reasoningEffort as OpenAI.Chat.ChatCompletionCreateParams["reasoning_effort"],
+		}
+	}
+
 	if (!shouldUseReasoningEffort({ model, settings })) return undefined
 	if (reasoningEffort === "disable" || !reasoningEffort) return undefined