feat(providers): enable GLM 5.3 for Z AI coding plans

Author: taltas

packages/types/src/providers/zai.ts

@@ -5,6 +5,7 @@ import { ZaiApiLine } from "../provider-settings.js"
 // https://docs.z.ai/guides/llm/glm-4-32b-0414-128k
 // https://docs.z.ai/guides/llm/glm-4.5
 // https://docs.z.ai/guides/llm/glm-4.6
+// https://docs.z.ai/guides/llm/glm-5.3
 // https://docs.z.ai/guides/llm/glm-5.1
 // https://docs.z.ai/guides/llm/glm-5-turbo
 // https://docs.z.ai/guides/overview/pricing
@@ -473,6 +474,42 @@ export const mainlandZAiModels = {
 	},
 } as const satisfies Record<string, ModelInfo>
 
+const glm53CodingPlanModelInfo = {
+	maxTokens: 131_072,
+	contextWindow: 1_000_000,
+	supportsImages: false,
+	supportsPromptCache: true,
+	supportsMaxTokens: true,
+	supportsReasoningEffort: ["low", "high", "max"],
+	requiredReasoningEffort: true,
+	reasoningEffort: "max",
+	preserveReasoning: true,
+	description:
+		"GLM-5.3 is Zhipu's flagship coding and agent model with a 1M context window, 128k max output, and always-on reasoning with configurable effort (Low/High/Max). Available to GLM Coding Plan users.",
+} as const satisfies ModelInfo
+
+export const internationalZAiCodingPlanOnlyModels = {
+	"glm-5.3": {
+		...glm53CodingPlanModelInfo,
+		// GLM-5.3 API pricing is not published yet; use GLM-5.2 pricing provisionally.
+		inputPrice: 1.4,
+		outputPrice: 4.4,
+		cacheWritesPrice: 0,
+		cacheReadsPrice: 0.26,
+	},
+} as const satisfies Record<string, ModelInfo>
+
+export const mainlandZAiCodingPlanOnlyModels = {
+	"glm-5.3": {
+		...glm53CodingPlanModelInfo,
+		// GLM-5.3 API pricing is not published yet; use GLM-5.2 pricing provisionally.
+		inputPrice: 0.68,
+		outputPrice: 2.28,
+		cacheWritesPrice: 0,
+		cacheReadsPrice: 0.13,
+	},
+} as const satisfies Record<string, ModelInfo>
+
 export const ZAI_DEFAULT_TEMPERATURE = 0.6
 
 export const zaiApiLineConfigs = {
@@ -497,3 +534,10 @@ export const zaiApiLineConfigs = {
 		isChina: true,
 	},
 } satisfies Record<ZaiApiLine, { name: string; baseUrl: string; isChina: boolean }>
+
+export function getZAiModels(apiLine: ZaiApiLine = "international_coding"): Record<string, ModelInfo> {
+	const isChina = zaiApiLineConfigs[apiLine].isChina
+	const regionalModels = isChina ? mainlandZAiModels : internationalZAiModels
+	const codingPlanOnlyModels = isChina ? mainlandZAiCodingPlanOnlyModels : internationalZAiCodingPlanOnlyModels
+	return apiLine.endsWith("_coding") ? { ...regionalModels, ...codingPlanOnlyModels } : regionalModels
+}

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

@@ -11,6 +11,7 @@ import {
 	internationalZAiModels,
 	mainlandZAiModels,
 	ZAI_DEFAULT_TEMPERATURE,
+	getZAiModels,
 } from "@roo-code/types"
 
 import { ZAiHandler } from "../zai"
@@ -141,6 +142,30 @@ describe("ZAiHandler", () => {
 			expect(model.info.cacheReadsPrice).toBe(0.26)
 		})
 
+		it("should expose GLM-5.3 for the international Coding Plan with provisional GLM-5.2 pricing", () => {
+			const handlerWithModel = new ZAiHandler({
+				apiModelId: "glm-5.3",
+				zaiApiKey: "test-zai-api-key",
+				zaiApiLine: "international_coding",
+			})
+			const model = handlerWithModel.getModel()
+			expect(model.id).toBe("glm-5.3")
+			expect(model.info).toMatchObject({
+				contextWindow: 1_000_000,
+				maxTokens: 131_072,
+				supportsImages: false,
+				supportsPromptCache: true,
+				supportsMaxTokens: true,
+				supportsReasoningEffort: ["low", "high", "max"],
+				requiredReasoningEffort: true,
+				reasoningEffort: "max",
+				preserveReasoning: true,
+			})
+			expect(model.info.inputPrice).toBe(1.4)
+			expect(model.info.outputPrice).toBe(4.4)
+			expect(model.info.cacheReadsPrice).toBe(0.26)
+		})
+
 		it("should return GLM-5-Turbo international model with thinking support", () => {
 			const testModelId: InternationalZAiModelId = "glm-5-turbo"
 			const handlerWithModel = new ZAiHandler({
@@ -277,6 +302,22 @@ describe("ZAiHandler", () => {
 			expect(model.info.cacheReadsPrice).toBe(0.13)
 		})
 
+		it("should expose GLM-5.3 for the China Coding Plan", () => {
+			const handlerWithModel = new ZAiHandler({
+				apiModelId: "glm-5.3",
+				zaiApiKey: "test-zai-api-key",
+				zaiApiLine: "china_coding",
+			})
+			const model = handlerWithModel.getModel()
+			expect(model.id).toBe("glm-5.3")
+			expect(model.info.supportsReasoningEffort).toEqual(["low", "high", "max"])
+			expect(model.info.requiredReasoningEffort).toBe(true)
+			expect(model.info.reasoningEffort).toBe("max")
+			expect(model.info.inputPrice).toBe(0.68)
+			expect(model.info.outputPrice).toBe(2.28)
+			expect(model.info.cacheReadsPrice).toBe(0.13)
+		})
+
 		it("should return GLM-4.7 China model with thinking support", () => {
 			const testModelId: MainlandZAiModelId = "glm-4.7"
 			const handlerWithModel = new ZAiHandler({
@@ -348,6 +389,16 @@ describe("ZAiHandler", () => {
 			expect(model.id).toBe(testModelId)
 			expect(model.info).toEqual(internationalZAiModels[testModelId])
 		})
+
+		it("should not expose Coding Plan-only models", () => {
+			expect(getZAiModels("international_api")).not.toHaveProperty("glm-5.3")
+			const handlerWithModel = new ZAiHandler({
+				apiModelId: "glm-5.3",
+				zaiApiKey: "test-zai-api-key",
+				zaiApiLine: "international_api",
+			})
+			expect(handlerWithModel.getModel().id).toBe(internationalZAiDefaultModelId)
+		})
 	})
 
 	describe("China API", () => {
@@ -387,6 +438,10 @@ describe("ZAiHandler", () => {
 			expect(model.id).toBe(testModelId)
 			expect(model.info).toEqual(mainlandZAiModels[testModelId])
 		})
+
+		it("should not expose Coding Plan-only models", () => {
+			expect(getZAiModels("china_api")).not.toHaveProperty("glm-5.3")
+		})
 	})
 
 	describe("Default behavior", () => {
@@ -613,6 +668,50 @@ describe("ZAiHandler", () => {
 			)
 		})
 
+		it("should keep GLM-5.3 reasoning enabled when a persisted setting requests disable", async () => {
+			const handlerWithModel = new ZAiHandler({
+				apiModelId: "glm-5.3",
+				zaiApiKey: "test-zai-api-key",
+				zaiApiLine: "international_coding",
+				reasoningEffort: "disable",
+			})
+
+			mockCreate.mockImplementationOnce(() => asyncStreamFrom([]))
+
+			const messageGenerator = handlerWithModel.createMessage("system prompt", [])
+			await messageGenerator.next()
+
+			expect(mockCreate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					model: "glm-5.3",
+					thinking: { type: "enabled" },
+					reasoning_effort: "max",
+				}),
+			)
+		})
+
+		it("should keep GLM-5.3 reasoning enabled when the master reasoning setting is disabled", async () => {
+			const handlerWithModel = new ZAiHandler({
+				apiModelId: "glm-5.3",
+				zaiApiKey: "test-zai-api-key",
+				zaiApiLine: "international_coding",
+				enableReasoningEffort: false,
+			})
+
+			mockCreate.mockImplementationOnce(() => asyncStreamFrom([]))
+
+			const messageGenerator = handlerWithModel.createMessage("system prompt", [])
+			await messageGenerator.next()
+
+			expect(mockCreate).toHaveBeenCalledWith(
+				expect.objectContaining({
+					model: "glm-5.3",
+					thinking: { type: "enabled" },
+					reasoning_effort: "max",
+				}),
+			)
+		})
+
 		it("should omit reasoning_effort for GLM-5.2 when reasoningEffort is set to disable", async () => {
 			const handlerWithModel = new ZAiHandler({
 				apiModelId: "glm-5.2",

src/api/providers/zai.ts

@@ -2,13 +2,12 @@ import { Anthropic } from "@anthropic-ai/sdk"
 import OpenAI from "openai"
 
 import {
-	internationalZAiModels,
-	mainlandZAiModels,
 	internationalZAiDefaultModelId,
 	mainlandZAiDefaultModelId,
 	type ModelInfo,
 	ZAI_DEFAULT_TEMPERATURE,
 	zaiApiLineConfigs,
+	getZAiModels,
 } from "@roo-code/types"
 
 import { type ApiHandlerOptions, getModelMaxOutputTokens } from "../../shared/api"
@@ -29,14 +28,15 @@ type ZAiChatCompletionParams = Omit<OpenAI.Chat.ChatCompletionCreateParamsStream
 
 export class ZAiHandler extends BaseOpenAiCompatibleProvider<string> {
 	constructor(options: ApiHandlerOptions) {
-		const isChina = zaiApiLineConfigs[options.zaiApiLine ?? "international_coding"].isChina
-		const models = (isChina ? mainlandZAiModels : internationalZAiModels) as unknown as Record<string, ModelInfo>
+		const apiLine = options.zaiApiLine ?? "international_coding"
+		const isChina = zaiApiLineConfigs[apiLine].isChina
+		const models = getZAiModels(apiLine)
 		const defaultModelId = (isChina ? mainlandZAiDefaultModelId : internationalZAiDefaultModelId) as string
 
 		super({
 			...options,
 			providerName: "Z.ai",
-			baseURL: zaiApiLineConfigs[options.zaiApiLine ?? "international_coding"].baseUrl,
+			baseURL: zaiApiLineConfigs[apiLine].baseUrl,
 			apiKey: options.zaiApiKey ?? "not-provided",
 			defaultProviderModelId: defaultModelId,
 			providerModels: models,
@@ -85,12 +85,15 @@ export class ZAiHandler extends BaseOpenAiCompatibleProvider<string> {
 			this.options.enableReasoningEffort === false
 				? undefined
 				: (this.options.reasoningEffort ?? info.reasoningEffort)
+		const requiresReasoning = info.requiredReasoningEffort === true
 		const effort =
-			raw && raw !== "disable" && Array.isArray(supported) && !supported.includes(raw)
+			requiresReasoning && (!raw || raw === "disable")
 				? info.reasoningEffort
-				: raw
+				: raw && Array.isArray(supported) && !supported.includes(raw)
+					? info.reasoningEffort
+					: raw
 		const reasoningEffort = effort && effort !== "disable" ? effort : undefined
-		const useReasoning = reasoningEffort !== undefined
+		const useReasoning = requiresReasoning || reasoningEffort !== undefined
 
 		const max_tokens =
 			this.options.modelMaxTokens ||
@@ -114,7 +117,7 @@ export class ZAiHandler extends BaseOpenAiCompatibleProvider<string> {
 			messages: [{ role: "system", content: systemPrompt }, ...convertedMessages],
 			stream: true,
 			stream_options: { include_usage: true },
-			// Thinking is ON by default for these models, so explicitly disable it when needed.
+			// Models with required reasoning stay enabled even when an old setting requests disable.
 			thinking: useReasoning ? { type: "enabled" } : { type: "disabled" },
 			reasoning_effort: reasoningEffort,
 			tools: this.convertToolsForOpenAI(metadata?.tools),

webview-ui/src/components/settings/ApiOptions.tsx

@@ -722,6 +722,7 @@ const ApiOptions = ({
 								models={getStaticModelsForProvider(
 									activeSelectedProvider,
 									t("settings:labels.useCustomArn"),
+									apiConfiguration,
 								)}
 								modelIdKey="apiModelId"
 								serviceName={getProviderServiceConfig(activeSelectedProvider).serviceName}

webview-ui/src/components/settings/ThinkingBudget.tsx

@@ -109,22 +109,27 @@ export const ThinkingBudget = ({ apiConfiguration, setApiConfigurationField, mod
 	// Clamp to availableOptions so the Select trigger always renders a valid option.
 	const storedReasoningEffort = apiConfiguration.reasoningEffort as ReasoningEffortOption | undefined
 	const rawReasoningEffort: ReasoningEffortOption = storedReasoningEffort || defaultReasoningEffort
+	const fallbackReasoningEffort = availableOptions.includes(defaultReasoningEffort)
+		? defaultReasoningEffort
+		: (availableOptions[0] ?? rawReasoningEffort)
 	const currentReasoningEffort: ReasoningEffortOption = availableOptions.includes(rawReasoningEffort)
 		? rawReasoningEffort
-		: (availableOptions[0] ?? rawReasoningEffort)
+		: fallbackReasoningEffort
 
 	// Set default reasoning effort when model supports it and no value is set
 	useEffect(() => {
-		if (isReasoningEffortSupported && !apiConfiguration.reasoningEffort) {
-			// Only set a default if reasoning is required, otherwise leave as undefined (which maps to "disable")
-			if (modelInfo?.requiredReasoningEffort && defaultReasoningEffort !== "disable") {
-				setApiConfigurationField("reasoningEffort", defaultReasoningEffort as ReasoningEffortExtended, false)
-			}
+		if (
+			isReasoningEffortSupported &&
+			modelInfo?.requiredReasoningEffort &&
+			storedReasoningEffort !== currentReasoningEffort &&
+			currentReasoningEffort !== "disable"
+		) {
+			setApiConfigurationField("reasoningEffort", currentReasoningEffort as ReasoningEffortExtended, false)
 		}
 	}, [
 		isReasoningEffortSupported,
-		apiConfiguration.reasoningEffort,
-		defaultReasoningEffort,
+		storedReasoningEffort,
+		currentReasoningEffort,
 		modelInfo?.requiredReasoningEffort,
 		setApiConfigurationField,
 	])

webview-ui/src/components/settings/__tests__/ThinkingBudget.spec.tsx

@@ -289,6 +289,26 @@ describe("ThinkingBudget", () => {
 			expect(screen.getByTestId("select")).toHaveAttribute("data-value", "low")
 		})
 
+		it("should normalize an invalid disabled value to the default for required reasoning", () => {
+			const setApiConfigurationField = vi.fn()
+			render(
+				<ThinkingBudget
+					{...defaultProps}
+					apiConfiguration={{ reasoningEffort: "disable" }}
+					setApiConfigurationField={setApiConfigurationField}
+					modelInfo={{
+						...reasoningEffortModelInfo,
+						supportsReasoningEffort: ["low", "high", "max"],
+						requiredReasoningEffort: true,
+						reasoningEffort: "max",
+					}}
+				/>,
+			)
+
+			expect(screen.getByTestId("select")).toHaveAttribute("data-value", "max")
+			expect(setApiConfigurationField).toHaveBeenCalledWith("reasoningEffort", "max", false)
+		})
+
 		it("should fall back to rawReasoningEffort when availableOptions is empty", () => {
 			// Covers the ?? rawReasoningEffort branch when availableOptions[0] is undefined
 			render(

webview-ui/src/components/settings/utils/__tests__/providerModelConfig.spec.ts

@@ -110,6 +110,15 @@ describe("providerModelConfig", () => {
 			expect(defaultId.length).toBeGreaterThan(0)
 		})
 
+		it("returns mainland default for Z.ai with china_api entrypoint", () => {
+			expect(
+				getDefaultModelIdForProvider("zai", {
+					apiProvider: "zai",
+					zaiApiLine: "china_api",
+				}),
+			).toBe(mainlandZAiDefaultModelId)
+		})
+
 		it("returns international default for Z.ai with international_coding entrypoint", () => {
 			const defaultId = getDefaultModelIdForProvider("zai", {
 				apiProvider: "zai",
@@ -177,6 +186,30 @@ describe("providerModelConfig", () => {
 			const models = getStaticModelsForProvider("openrouter")
 			expect(Object.keys(models).length).toBe(0)
 		})
+
+		it("shows GLM-5.3 only for Z.ai Coding Plan entrypoints", () => {
+			const internationalCoding = getStaticModelsForProvider("zai", undefined, {
+				apiProvider: "zai",
+				zaiApiLine: "international_coding",
+			})
+			const chinaCoding = getStaticModelsForProvider("zai", undefined, {
+				apiProvider: "zai",
+				zaiApiLine: "china_coding",
+			})
+			const internationalApi = getStaticModelsForProvider("zai", undefined, {
+				apiProvider: "zai",
+				zaiApiLine: "international_api",
+			})
+			const chinaApi = getStaticModelsForProvider("zai", undefined, {
+				apiProvider: "zai",
+				zaiApiLine: "china_api",
+			})
+
+			expect(internationalCoding).toHaveProperty("glm-5.3")
+			expect(chinaCoding).toHaveProperty("glm-5.3")
+			expect(internationalApi).not.toHaveProperty("glm-5.3")
+			expect(chinaApi).not.toHaveProperty("glm-5.3")
+		})
 	})
 
 	describe("isStaticModelProvider", () => {