feat: Adding more settings and control over Gemini

packages/types/src/provider-settings.ts

@@ -156,6 +156,12 @@ const lmStudioSchema = baseProviderSettingsSchema.extend({
 const geminiSchema = apiModelIdProviderModelSchema.extend({
 	geminiApiKey: z.string().optional(),
 	googleGeminiBaseUrl: z.string().optional(),
+	topP: z.number().optional(),
+	topK: z.number().optional(),
+	maxOutputTokens: z.number().optional(),
+	enableUrlContext: z.boolean().optional(),
+	enableGrounding: z.boolean().optional(),
+	contextLimit: z.number().optional(),
 })
 
 const openAiNativeSchema = apiModelIdProviderModelSchema.extend({

src/api/providers/__tests__/gemini-handler.spec.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from "vitest"
+import { GeminiHandler } from "../gemini"
+import type { ApiHandlerOptions } from "../../../shared/api"
+import type { Anthropic } from "@anthropic-ai/sdk"
+
+describe("GeminiHandler backend support", () => {
+	it("slices messages when contextLimit is set", async () => {
+		const options = { apiProvider: "gemini", contextLimit: 1 } as ApiHandlerOptions
+		const handler = new GeminiHandler(options)
+		const stub = vi.fn().mockReturnValue((async function* () {})())
+		// @ts-ignore access private client
+		handler["client"].models.generateContentStream = stub
+		const messages = [
+			{ role: "user", content: [{ type: "text", text: "first" }] },
+			{ role: "assistant", content: [{ type: "text", text: "second" }] },
+		] as Anthropic.Messages.MessageParam[]
+		for await (const _ of handler.createMessage("instr", messages)) {
+		}
+		expect(stub).toHaveBeenCalledOnce()
+		const params = stub.mock.calls[0][0]
+		expect(params.contents).toHaveLength(1)
+	})
+
+	it("passes maxOutputTokens, topP, topK, and tools for URL context and grounding in config", async () => {
+		const options = {
+			apiProvider: "gemini",
+			maxOutputTokens: 5,
+			topP: 0.5,
+			topK: 10,
+			enableUrlContext: true,
+			enableGrounding: true,
+		} as ApiHandlerOptions
+		const handler = new GeminiHandler(options)
+		const stub = vi.fn().mockReturnValue((async function* () {})())
+		// @ts-ignore access private client
+		handler["client"].models.generateContentStream = stub
+		await handler.createMessage("instr", [] as any).next()
+		const config = stub.mock.calls[0][0].config
+		expect(config.maxOutputTokens).toBe(5)
+		expect(config.topP).toBe(0.5)
+		expect(config.topK).toBe(10)
+		expect(config.tools).toEqual([{ urlContext: {} }, { googleSearch: {} }])
+	})
+
+	it("completePrompt passes config overrides without tools when URL context and grounding disabled", async () => {
+		const options = {
+			apiProvider: "gemini",
+			maxOutputTokens: 7,
+			topP: 0.7,
+			topK: 3,
+			enableUrlContext: false,
+			enableGrounding: false,
+		} as ApiHandlerOptions
+		const handler = new GeminiHandler(options)
+		const stub = vi.fn().mockResolvedValue({ text: "ok" })
+		// @ts-ignore access private client
+		handler["client"].models.generateContent = stub
+		const res = await handler.completePrompt("hi")
+		expect(res).toBe("ok")
+		expect(stub).toHaveBeenCalledWith(
+			expect.objectContaining({
+				config: expect.objectContaining({
+					maxOutputTokens: 7,
+					topP: 0.7,
+					topK: 3,
+				}),
+			}),
+		)
+		const promptConfig = stub.mock.calls[0][0].config
+		expect(promptConfig.tools).toBeUndefined()
+	})
+})

src/api/providers/gemini.ts

@@ -65,15 +65,27 @@ export class GeminiHandler extends BaseProvider implements SingleCompletionHandl
 	): ApiStream {
 		const { id: model, info, reasoning: thinkingConfig, maxTokens } = this.getModel()
 
-		const contents = messages.map(convertAnthropicMessageToGemini)
+		const limitedMessages = this.options.contextLimit ? messages.slice(-this.options.contextLimit) : messages
+		const contents = limitedMessages.map(convertAnthropicMessageToGemini)
 
-		const config: GenerateContentConfig = {
+		const tools: Array<Record<string, object>> = []
+		if (this.options.enableUrlContext) {
+			tools.push({ urlContext: {} })
+		}
+		if (this.options.enableGrounding) {
+			tools.push({ googleSearch: {} })
+		}
+		const rawConfig = {
 			systemInstruction,
 			httpOptions: this.options.googleGeminiBaseUrl ? { baseUrl: this.options.googleGeminiBaseUrl } : undefined,
 			thinkingConfig,
-			maxOutputTokens: this.options.modelMaxTokens ?? maxTokens ?? undefined,
+			maxOutputTokens: this.options.maxOutputTokens ?? this.options.modelMaxTokens ?? maxTokens ?? undefined,
 			temperature: this.options.modelTemperature ?? 0,
+			topP: this.options.topP,
+			topK: this.options.topK,
+			...(tools.length > 0 ? { tools } : {}),
 		}
+		const config = rawConfig as unknown as GenerateContentConfig
 
 		const params: GenerateContentParameters = { model, contents, config }
 
@@ -132,9 +144,16 @@ export class GeminiHandler extends BaseProvider implements SingleCompletionHandl
 	override getModel() {
 		const modelId = this.options.apiModelId
 		let id = modelId && modelId in geminiModels ? (modelId as GeminiModelId) : geminiDefaultModelId
-		const info: ModelInfo = geminiModels[id]
+		let info: ModelInfo = geminiModels[id]
 		const params = getModelParams({ format: "gemini", modelId: id, model: info, settings: this.options })
 
+		if (this.options.contextLimit) {
+			info = {
+				...info,
+				contextWindow: this.options.contextLimit,
+			}
+		}
+
 		// The `:thinking` suffix indicates that the model is a "Hybrid"
 		// reasoning model and that reasoning is required to be enabled.
 		// The actual model ID honored by Gemini's API does not have this
@@ -146,15 +165,29 @@ export class GeminiHandler extends BaseProvider implements SingleCompletionHandl
 		try {
 			const { id: model } = this.getModel()
 
+			const tools: Array<Record<string, object>> = []
+			if (this.options.enableUrlContext) {
+				tools.push({ urlContext: {} })
+			}
+			if (this.options.enableGrounding) {
+				tools.push({ googleSearch: {} })
+			}
+			const rawPromptConfig = {
+				httpOptions: this.options.googleGeminiBaseUrl
+					? { baseUrl: this.options.googleGeminiBaseUrl }
+					: undefined,
+				temperature: this.options.modelTemperature ?? 0,
+				maxOutputTokens: this.options.maxOutputTokens ?? this.options.modelMaxTokens,
+				topP: this.options.topP,
+				topK: this.options.topK,
+				...(tools.length > 0 ? { tools } : {}),
+			}
+			const promptConfig = rawPromptConfig as unknown as GenerateContentConfig
+
 			const result = await this.client.models.generateContent({
 				model,
 				contents: [{ role: "user", parts: [{ text: prompt }] }],
-				config: {
-					httpOptions: this.options.googleGeminiBaseUrl
-						? { baseUrl: this.options.googleGeminiBaseUrl }
-						: undefined,
-					temperature: this.options.modelTemperature ?? 0,
-				},
+				config: promptConfig,
 			})
 
 			return result.text ?? ""

src/core/sliding-window/__tests__/sliding-window.spec.ts

@@ -250,6 +250,30 @@ describe("Sliding Window", () => {
 			{ role: "assistant", content: "Fourth message" },
 			{ role: "user", content: "Fifth message" },
 		]
+		it("should use contextLimit as contextWindow when apiProvider is gemini", async () => {
+			const contextLimit = 2
+			const messages: ApiMessage[] = [
+				{ role: "user", content: "First message" },
+				{ role: "assistant", content: "Second message" },
+				{ role: "user", content: "Third message" },
+				{ role: "assistant", content: "Fourth message" },
+				{ role: "user", content: "" },
+			]
+			const result = await truncateConversationIfNeeded({
+				messages,
+				totalTokens: 2,
+				contextWindow: contextLimit,
+				maxTokens: null,
+				apiHandler: mockApiHandler,
+				autoCondenseContext: false,
+				autoCondenseContextPercent: 100,
+				systemPrompt: "",
+				taskId,
+				profileThresholds: {},
+				currentProfileId: "default",
+			})
+			expect(result.messages).toEqual([messages[0], messages[3], messages[4]])
+		})
 
 		it("should not truncate if tokens are below max tokens threshold", async () => {
 			const modelInfo = createModelInfo(100000, 30000)

src/core/task/Task.ts

@@ -1706,7 +1706,10 @@ export class Task extends EventEmitter<ClineEvents> {
 				? this.apiConfiguration.modelMaxTokens || DEFAULT_THINKING_MODEL_MAX_TOKENS
 				: modelInfo.maxTokens
 
-			const contextWindow = modelInfo.contextWindow
+			const contextWindow =
+				this.apiConfiguration.apiProvider === "gemini" && this.apiConfiguration.contextLimit
+					? this.apiConfiguration.contextLimit
+					: modelInfo.contextWindow
 
 			const truncateResult = await truncateConversationIfNeeded({
 				messages: this.apiConversationHistory,

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

@@ -74,6 +74,10 @@ export interface ApiOptionsProps {
 	fromWelcomeView?: boolean
 	errorMessage: string | undefined
 	setErrorMessage: React.Dispatch<React.SetStateAction<string | undefined>>
+	currentProfileId?: string
+	profileThresholds?: Record<string, number>
+	autoCondenseContextPercent?: number
+	setProfileThreshold?: (profileId: string, threshold: number) => void
 }
 
 const ApiOptions = ({
@@ -83,6 +87,10 @@ const ApiOptions = ({
 	fromWelcomeView,
 	errorMessage,
 	setErrorMessage,
+	currentProfileId,
+	profileThresholds,
+	autoCondenseContextPercent,
+	setProfileThreshold,
 }: ApiOptionsProps) => {
 	const { t } = useAppTranslation()
 	const { organizationAllowList } = useExtensionState()
@@ -411,7 +419,15 @@ const ApiOptions = ({
 			)}
 
 			{selectedProvider === "gemini" && (
-				<Gemini apiConfiguration={apiConfiguration} setApiConfigurationField={setApiConfigurationField} />
+				<Gemini
+					apiConfiguration={apiConfiguration}
+					setApiConfigurationField={setApiConfigurationField}
+					currentModelId={selectedModelId}
+					currentProfileId={currentProfileId}
+					profileThresholds={profileThresholds}
+					autoCondenseContextPercent={autoCondenseContextPercent}
+					setProfileThreshold={setProfileThreshold}
+				/>
 			)}
 
 			{selectedProvider === "openai" && (

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

@@ -177,6 +177,15 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 
 	const apiConfiguration = useMemo(() => cachedState.apiConfiguration ?? {}, [cachedState.apiConfiguration])
 
+	const getCurrentProfileId = useCallback(() => {
+		if (!currentApiConfigName || !listApiConfigMeta) {
+			return currentApiConfigName
+		}
+
+		const profile = listApiConfigMeta.find((p) => p.name === currentApiConfigName)
+		return profile ? profile.id : currentApiConfigName
+	}, [currentApiConfigName, listApiConfigMeta])
+
 	useEffect(() => {
 		// Update only when currentApiConfigName is changed.
 		// Expected to be triggered by loadApiConfiguration/upsertApiConfiguration.
@@ -233,6 +242,16 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 		})
 	}, [])
 
+	const setProfileThreshold = useCallback(
+		(profileId: string, threshold: number) => {
+			setCachedStateField("profileThresholds", {
+				...profileThresholds,
+				[profileId]: threshold,
+			})
+		},
+		[profileThresholds, setCachedStateField],
+	)
+
 	const setTelemetrySetting = useCallback((setting: TelemetrySetting) => {
 		setCachedState((prevState) => {
 			if (prevState.telemetrySetting === setting) {
@@ -576,6 +595,10 @@ const SettingsView = forwardRef<SettingsViewRef, SettingsViewProps>(({ onDone, t
 									setApiConfigurationField={setApiConfigurationField}
 									errorMessage={errorMessage}
 									setErrorMessage={setErrorMessage}
+									currentProfileId={getCurrentProfileId()}
+									profileThresholds={profileThresholds || {}}
+									autoCondenseContextPercent={autoCondenseContextPercent || 75}
+									setProfileThreshold={setProfileThreshold}
 								/>
 							</Section>
 						</div>