feat: add DeepSeek V4 Flash and V4 Pro model support

- Add deepseek-v4-flash and deepseek-v4-pro model entries with 1M context
  window, 384K max output, and correct pricing
- Support optional thinking mode via thinking: { type: "enabled" } parameter
- Support reasoning_effort parameter (high/max) for V4 models
- Update handler to detect V4 models via supportsReasoningEffort and
  conditionally enable thinking based on user settings
- Add comprehensive tests for V4 model info, thinking parameters, and
  reasoning effort control

Author: roomote

packages/types/src/providers/deepseek.ts

@@ -32,6 +32,36 @@ export const deepSeekModels = {
 		cacheReadsPrice: 0.028, // $0.028 per million tokens (cache hit) - Updated Dec 9, 2025
 		description: `DeepSeek-V3.2 (Thinking Mode) achieves performance comparable to OpenAI-o1 across math, code, and reasoning tasks. Supports Chain of Thought reasoning with up to 8K output tokens. Supports JSON output, tool calls, and chat prefix completion (beta).`,
 	},
+	"deepseek-v4-flash": {
+		maxTokens: 384_000, // 384K max output
+		contextWindow: 1_000_000, // 1M context window
+		supportsImages: false,
+		supportsPromptCache: true,
+		supportsReasoningEffort: ["disable", "high"],
+		reasoningEffort: "high",
+		preserveReasoning: true,
+		inputPrice: 0.14, // $0.14 per million tokens (cache miss)
+		outputPrice: 0.28, // $0.28 per million tokens
+		cacheWritesPrice: 0.14, // $0.14 per million tokens (cache miss)
+		cacheReadsPrice: 0.028, // $0.028 per million tokens (cache hit)
+		description:
+			"DeepSeek V4 Flash is a fast, cost-effective model with 1M context window and optional thinking mode. Supports thinking and non-thinking modes with configurable reasoning effort.",
+	},
+	"deepseek-v4-pro": {
+		maxTokens: 384_000, // 384K max output
+		contextWindow: 1_000_000, // 1M context window
+		supportsImages: false,
+		supportsPromptCache: true,
+		supportsReasoningEffort: ["disable", "high"],
+		reasoningEffort: "high",
+		preserveReasoning: true,
+		inputPrice: 1.74, // $1.74 per million tokens (cache miss)
+		outputPrice: 3.48, // $3.48 per million tokens
+		cacheWritesPrice: 1.74, // $1.74 per million tokens (cache miss)
+		cacheReadsPrice: 0.145, // $0.145 per million tokens (cache hit)
+		description:
+			"DeepSeek V4 Pro is a high-performance model with 1M context window and optional thinking mode. Delivers top-tier reasoning capabilities with configurable reasoning effort.",
+	},
 } as const satisfies Record<string, ModelInfo>
 
 // https://api-docs.deepseek.com/quick_start/parameter_settings

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

@@ -31,13 +31,16 @@ vi.mock("openai", () => {
 
 						// Check if this is a reasoning_content test by looking at model
 						const isReasonerModel = options.model?.includes("deepseek-reasoner")
+						const isV4ThinkingModel =
+							options.thinking?.type === "enabled" && options.model?.includes("deepseek-v4")
+						const isThinkingModel = isReasonerModel || isV4ThinkingModel
 						const isToolCallTest = options.tools?.length > 0
 
 						// Return async iterator for streaming
 						return {
 							[Symbol.asyncIterator]: async function* () {
-								// For reasoner models, emit reasoning_content first
-								if (isReasonerModel) {
+								// For thinking models, emit reasoning_content first
+								if (isThinkingModel) {
 									yield {
 										choices: [
 											{
@@ -58,8 +61,8 @@ vi.mock("openai", () => {
 									}
 								}
 
-								// For tool call tests with reasoner, emit tool call
-								if (isReasonerModel && isToolCallTest) {
+								// For tool call tests with thinking models, emit tool call
+								if (isThinkingModel && isToolCallTest) {
 									yield {
 										choices: [
 											{
@@ -508,4 +511,103 @@ describe("DeepSeekHandler", () => {
 			expect(toolCallChunks[0].name).toBe("get_weather")
 		})
 	})
+
+	describe("V4 models", () => {
+		const systemPrompt = "You are a helpful assistant."
+		const messages: Anthropic.Messages.MessageParam[] = [
+			{
+				role: "user",
+				content: [
+					{
+						type: "text" as const,
+						text: "Hello!",
+					},
+				],
+			},
+		]
+
+		it("should return correct model info for deepseek-v4-flash", () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-flash",
+			})
+			const model = v4Handler.getModel()
+			expect(model.id).toBe("deepseek-v4-flash")
+			expect(model.info.maxTokens).toBe(384_000)
+			expect(model.info.contextWindow).toBe(1_000_000)
+			expect(model.info.supportsPromptCache).toBe(true)
+			expect((model.info as ModelInfo).preserveReasoning).toBe(true)
+			expect((model.info as ModelInfo).supportsReasoningEffort).toEqual(["disable", "high"])
+		})
+
+		it("should return correct model info for deepseek-v4-pro", () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-pro",
+			})
+			const model = v4Handler.getModel()
+			expect(model.id).toBe("deepseek-v4-pro")
+			expect(model.info.maxTokens).toBe(384_000)
+			expect(model.info.contextWindow).toBe(1_000_000)
+			expect(model.info.supportsPromptCache).toBe(true)
+			expect((model.info as ModelInfo).preserveReasoning).toBe(true)
+			expect((model.info as ModelInfo).supportsReasoningEffort).toEqual(["disable", "high"])
+		})
+
+		it("should pass thinking and reasoning_effort for V4 models with default reasoning effort", async () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-pro",
+			})
+
+			const stream = v4Handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// Consume the stream
+			}
+
+			expect(mockCreate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					thinking: { type: "enabled" },
+					reasoning_effort: "high",
+				}),
+				{},
+			)
+		})
+
+		it("should NOT pass thinking for V4 models when reasoning effort is disabled", async () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-flash",
+				enableReasoningEffort: true,
+				reasoningEffort: "disable" as any,
+			})
+
+			const stream = v4Handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// Consume the stream
+			}
+
+			const callArgs = mockCreate.mock.calls[0][0]
+			expect(callArgs.thinking).toBeUndefined()
+			expect(callArgs.reasoning_effort).toBeUndefined()
+		})
+
+		it("should handle reasoning_content in streaming responses for V4 models", async () => {
+			const v4Handler = new DeepSeekHandler({
+				...mockOptions,
+				apiModelId: "deepseek-v4-pro",
+			})
+
+			const stream = v4Handler.createMessage(systemPrompt, messages)
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			// Should have reasoning chunks since thinking is enabled by default
+			const reasoningChunks = chunks.filter((chunk) => chunk.type === "reasoning")
+			expect(reasoningChunks.length).toBeGreaterThan(0)
+			expect(reasoningChunks[0].text).toBe("Let me think about this...")
+		})
+	})
 })

src/api/providers/deepseek.ts

@@ -6,9 +6,10 @@ import {
 	deepSeekDefaultModelId,
 	DEEP_SEEK_DEFAULT_TEMPERATURE,
 	OPENAI_AZURE_AI_INFERENCE_PATH,
+	type ModelInfo,
 } from "@roo-code/types"
 
-import type { ApiHandlerOptions } from "../../shared/api"
+import { type ApiHandlerOptions, shouldUseReasoningEffort } from "../../shared/api"
 
 import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
 import { getModelParams } from "../transform/model-params"
@@ -17,9 +18,10 @@ import { convertToR1Format } from "../transform/r1-format"
 import { OpenAiHandler } from "./openai"
 import type { ApiHandlerCreateMessageMetadata } from "../index"
 
-// Custom interface for DeepSeek params to support thinking mode
+// Custom interface for DeepSeek params to support thinking mode and reasoning effort
 type DeepSeekChatCompletionParams = OpenAI.Chat.ChatCompletionCreateParamsStreaming & {
 	thinking?: { type: "enabled" | "disabled" }
+	reasoning_effort?: string
 }
 
 export class DeepSeekHandler extends OpenAiHandler {
@@ -55,27 +57,42 @@ export class DeepSeekHandler extends OpenAiHandler {
 		const modelId = this.options.apiModelId ?? deepSeekDefaultModelId
 		const { info: modelInfo } = this.getModel()
 
-		// Check if this is a thinking-enabled model (deepseek-reasoner)
-		const isThinkingModel = modelId.includes("deepseek-reasoner")
+		// Check if this is a thinking-enabled model
+		// deepseek-reasoner always uses thinking mode
+		// V4 models (deepseek-v4-flash, deepseek-v4-pro) support optional thinking via supportsReasoningEffort
+		const isLegacyThinkingModel = modelId.includes("deepseek-reasoner")
+		const isV4ThinkingModel = Array.isArray((modelInfo as ModelInfo).supportsReasoningEffort)
+		const useThinking =
+			isLegacyThinkingModel ||
+			(isV4ThinkingModel && shouldUseReasoningEffort({ model: modelInfo, settings: this.options }))
 
 		// Convert messages to R1 format (merges consecutive same-role messages)
 		// This is required for DeepSeek which does not support successive messages with the same role
-		// For thinking models (deepseek-reasoner), enable mergeToolResultText to preserve reasoning_content
+		// For thinking models, enable mergeToolResultText to preserve reasoning_content
 		// during tool call sequences. Without this, environment_details text after tool_results would
 		// create user messages that cause DeepSeek to drop all previous reasoning_content.
 		// See: https://api-docs.deepseek.com/guides/thinking_mode
 		const convertedMessages = convertToR1Format([{ role: "user", content: systemPrompt }, ...messages], {
-			mergeToolResultText: isThinkingModel,
+			mergeToolResultText: useThinking,
 		})
 
+		// Resolve reasoning effort for V4 models, filtering out control values
+		const rawEffort =
+			isV4ThinkingModel && useThinking
+				? (this.options.reasoningEffort ?? (modelInfo as ModelInfo).reasoningEffort ?? "high")
+				: undefined
+		const reasoningEffort = rawEffort && rawEffort !== "disable" && rawEffort !== "none" ? rawEffort : undefined
+
 		const requestOptions: DeepSeekChatCompletionParams = {
 			model: modelId,
 			temperature: this.options.modelTemperature ?? DEEP_SEEK_DEFAULT_TEMPERATURE,
 			messages: convertedMessages,
 			stream: true as const,
 			stream_options: { include_usage: true },
-			// Enable thinking mode for deepseek-reasoner or when tools are used with thinking model
-			...(isThinkingModel && { thinking: { type: "enabled" } }),
+			// Enable thinking mode for deepseek-reasoner (always) or V4 models (when reasoning is enabled)
+			...(useThinking && { thinking: { type: "enabled" } }),
+			// Add reasoning_effort for V4 models when thinking is enabled
+			...(reasoningEffort && { reasoning_effort: reasoningEffort as "low" | "medium" | "high" }),
 			tools: this.convertToolsForOpenAI(metadata?.tools),
 			tool_choice: metadata?.tool_choice,
 			parallel_tool_calls: metadata?.parallelToolCalls ?? true,