Adding nebius to roocode

Author: arafatkatze

evals/apps/web/src/app/runs/new/new-run.tsx

@@ -176,6 +176,7 @@ export function NewRun() {
 					ollamaModelId,
 					lmStudioModelId,
 					openAiModelId,
+					nebiusModelId,
 				} = providerSettings
 
 				switch (apiProvider) {
@@ -210,6 +211,9 @@ export function NewRun() {
 					case "lmstudio":
 						setValue("model", lmStudioModelId ?? "")
 						break
+					case "nebius":
+						setValue("model", nebiusModelId ?? "")
+						break
 					default:
 						throw new Error(`Unsupported API provider: ${apiProvider}`)
 				}

evals/packages/types/src/roo-code.ts

@@ -478,6 +478,12 @@ const litellmSchema = z.object({
 	litellmModelId: z.string().optional(),
 })
 
+const nebiusSchema = z.object({
+	nebiusBaseUrl: z.string().optional(),
+	nebiusApiKey: z.string().optional(),
+	nebiusModelId: z.string().optional(),
+})
+
 const defaultSchema = z.object({
 	apiProvider: z.undefined(),
 })
@@ -589,6 +595,11 @@ export const providerSettingsSchemaDiscriminated = z
 				apiProvider: z.literal("litellm"),
 			}),
 		),
+		nebiusSchema.merge(
+			z.object({
+				apiProvider: z.literal("nebius"),
+			}),
+		),
 		defaultSchema,
 	])
 	.and(genericProviderSettingsSchema)
@@ -616,6 +627,7 @@ export const providerSettingsSchema = z.object({
 	...groqSchema.shape,
 	...chutesSchema.shape,
 	...litellmSchema.shape,
+	...nebiusSchema.shape,
 	...genericProviderSettingsSchema.shape,
 })
 
@@ -716,6 +728,9 @@ const providerSettingsRecord: ProviderSettingsRecord = {
 	litellmBaseUrl: undefined,
 	litellmApiKey: undefined,
 	litellmModelId: undefined,
+	nebiusBaseUrl: undefined,
+	nebiusApiKey: undefined,
+	nebiusModelId: undefined,
 }
 
 export const PROVIDER_SETTINGS_KEYS = Object.keys(providerSettingsRecord) as Keys<ProviderSettings>[]

src/api/index.ts

@@ -24,6 +24,7 @@ import { XAIHandler } from "./providers/xai"
 import { GroqHandler } from "./providers/groq"
 import { ChutesHandler } from "./providers/chutes"
 import { LiteLLMHandler } from "./providers/litellm"
+import { NebiusHandler } from "./providers/nebius"
 
 export interface SingleCompletionHandler {
 	completePrompt(prompt: string): Promise<string>
@@ -104,6 +105,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new ChutesHandler(options)
 		case "litellm":
 			return new LiteLLMHandler(options)
+		case "nebius":
+			return new NebiusHandler(options)
 		default:
 			return new AnthropicHandler(options)
 	}

src/api/providers/fetchers/modelCache.ts

@@ -5,15 +5,16 @@ import NodeCache from "node-cache"
 
 import { ContextProxy } from "../../../core/config/ContextProxy"
 import { getCacheDirectoryPath } from "../../../utils/storage"
-import { RouterName, ModelRecord } from "../../../shared/api"
+import { RouterName, ModelRecord, GetModelsOptions } from "../../../shared/api"
 import { fileExistsAtPath } from "../../../utils/fs"
 
 import { getOpenRouterModels } from "./openrouter"
 import { getRequestyModels } from "./requesty"
 import { getGlamaModels } from "./glama"
 import { getUnboundModels } from "./unbound"
 import { getLiteLLMModels } from "./litellm"
-import { GetModelsOptions } from "../../../shared/api"
+import { getNebiusModels } from "./nebius"
+
 const memoryCache = new NodeCache({ stdTTL: 5 * 60, checkperiod: 5 * 60 })
 
 async function writeModels(router: RouterName, data: ModelRecord) {
@@ -68,6 +69,10 @@ export const getModels = async (options: GetModelsOptions): Promise<ModelRecord>
 				// Type safety ensures apiKey and baseUrl are always provided for litellm
 				models = await getLiteLLMModels(options.apiKey, options.baseUrl)
 				break
+			case "nebius":
+				// Type safety ensures apiKey and baseUrl are always provided for nebius
+				models = await getNebiusModels(options.apiKey, options.baseUrl)
+				break
 			default: {
 				// Ensures router is exhaustively checked if RouterName is a strict union
 				const exhaustiveCheck: never = provider

src/api/providers/fetchers/nebius.ts

@@ -0,0 +1,58 @@
+import axios from "axios"
+import { OPEN_ROUTER_COMPUTER_USE_MODELS, ModelRecord } from "../../../shared/api"
+
+/**
+ * Fetches available models from a Nebius server
+ *
+ * @param apiKey The API key for the Nebius server
+ * @param baseUrl The base URL of the Nebius server
+ * @returns A promise that resolves to a record of model IDs to model info
+ */
+export async function getNebiusModels(apiKey: string, baseUrl: string): Promise<ModelRecord> {
+	try {
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+		}
+
+		if (apiKey) {
+			headers["Authorization"] = `Bearer ${apiKey}`
+		}
+
+		const response = await axios.get(`${baseUrl}/v1/model/info`, { headers })
+		const models: ModelRecord = {}
+
+		const computerModels = Array.from(OPEN_ROUTER_COMPUTER_USE_MODELS)
+
+		// Process the model info from the response
+		if (response.data && response.data.data && Array.isArray(response.data.data)) {
+			for (const model of response.data.data) {
+				const modelName = model.model_name
+				const modelInfo = model.model_info
+				const nebiusModelName = model?.nebius_params?.model as string | undefined
+
+				if (!modelName || !modelInfo || !nebiusModelName) continue
+
+				models[modelName] = {
+					maxTokens: modelInfo.max_tokens || 8192,
+					contextWindow: modelInfo.max_input_tokens || 200000,
+					supportsImages: Boolean(modelInfo.supports_vision),
+					// nebius_params.model may have a prefix like openrouter/
+					supportsComputerUse: computerModels.some((computer_model) =>
+						nebiusModelName.endsWith(computer_model),
+					),
+					supportsPromptCache: Boolean(modelInfo.supports_prompt_caching),
+					inputPrice: modelInfo.input_cost_per_token ? modelInfo.input_cost_per_token * 1000000 : undefined,
+					outputPrice: modelInfo.output_cost_per_token
+						? modelInfo.output_cost_per_token * 1000000
+						: undefined,
+					description: `${modelName} via Nebius proxy`,
+				}
+			}
+		}
+
+		return models
+	} catch (error) {
+		console.error("Error fetching Nebius models:", error)
+		return {}
+	}
+}

src/api/providers/nebius.ts

@@ -0,0 +1,83 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { ApiStream } from "../transform/stream"
+import { convertToR1Format } from "../transform/r1-format"
+// Removed unused imports: ApiHandler, nebiusModels, ModelInfo, NebiusModelId
+
+import { SingleCompletionHandler } from "../index"
+import { RouterProvider } from "./router-provider"
+
+import { ApiHandlerOptions, nebiusDefaultModelId, nebiusDefaultModelInfo } from "../../shared/api"
+
+export class NebiusHandler extends RouterProvider implements SingleCompletionHandler {
+	constructor(options: ApiHandlerOptions) {
+		super({
+			options,
+			name: "nebius",
+			baseURL: "https://api.studio.nebius.ai/v1",
+			apiKey: options.nebiusApiKey || "dummy-key",
+			modelId: options.nebiusModelId,
+			defaultModelId: nebiusDefaultModelId,
+			defaultModelInfo: nebiusDefaultModelInfo,
+		})
+	}
+
+	async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
+		const model = this.getModel()
+
+		const openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = model.id.includes("DeepSeek-R1")
+			? convertToR1Format([{ role: "user", content: systemPrompt }, ...messages])
+			: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)]
+
+		const stream = await this.client.chat.completions.create({
+			model: model.id,
+			messages: openAiMessages,
+			temperature: 0,
+			stream: true,
+			stream_options: { include_usage: true },
+		})
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+			if (delta?.content) {
+				yield {
+					type: "text",
+					text: delta.content,
+				}
+			}
+
+			if (chunk.usage) {
+				yield {
+					type: "usage",
+					inputTokens: chunk.usage.prompt_tokens || 0,
+					outputTokens: chunk.usage.completion_tokens || 0,
+				}
+			}
+		}
+	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		const { id: modelId, info } = await this.fetchModel()
+
+		try {
+			const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
+				model: modelId,
+				messages: [{ role: "user", content: prompt }],
+			}
+
+			if (this.supportsTemperature(modelId)) {
+				requestOptions.temperature = this.options.modelTemperature ?? 0
+			}
+
+			requestOptions.max_tokens = info.maxTokens
+
+			const response = await this.client.chat.completions.create(requestOptions)
+			return response.choices[0]?.message.content || ""
+		} catch (error) {
+			if (error instanceof Error) {
+				throw new Error(`nebius completion error: ${error.message}`)
+			}
+			throw error
+		}
+	}
+}

src/core/webview/__tests__/ClineProvider.test.ts

@@ -2253,6 +2253,7 @@ describe("ClineProvider - Router Models", () => {
 				glama: mockModels,
 				unbound: mockModels,
 				litellm: mockModels,
+				nebius: {},
 			},
 		})
 	})
@@ -2294,6 +2295,7 @@ describe("ClineProvider - Router Models", () => {
 				glama: mockModels,
 				unbound: {},
 				litellm: {},
+				nebius: {},
 			},
 		})
 
@@ -2391,6 +2393,7 @@ describe("ClineProvider - Router Models", () => {
 				glama: mockModels,
 				unbound: mockModels,
 				litellm: {},
+				nebius: {},
 			},
 		})
 	})

src/core/webview/__tests__/webviewMessageHandler.test.ts

@@ -70,6 +70,7 @@ describe("webviewMessageHandler - requestRouterModels", () => {
 				glama: mockModels,
 				unbound: mockModels,
 				litellm: mockModels,
+				nebius: {},
 			},
 		})
 	})
@@ -155,6 +156,7 @@ describe("webviewMessageHandler - requestRouterModels", () => {
 				glama: mockModels,
 				unbound: mockModels,
 				litellm: {},
+				nebius: {},
 			},
 		})
 	})
@@ -190,6 +192,7 @@ describe("webviewMessageHandler - requestRouterModels", () => {
 				glama: mockModels,
 				unbound: {},
 				litellm: {},
+				nebius: {},
 			},
 		})
 

src/core/webview/webviewMessageHandler.ts

@@ -295,6 +295,7 @@ export const webviewMessageHandler = async (provider: ClineProvider, message: We
 				glama: {},
 				unbound: {},
 				litellm: {},
+				nebius: {},
 			}
 
 			const safeGetModels = async (options: GetModelsOptions): Promise<ModelRecord> => {
@@ -325,6 +326,15 @@ export const webviewMessageHandler = async (provider: ClineProvider, message: We
 				})
 			}
 
+			const nebiusApiKey = apiConfiguration.nebiusApiKey || message?.values?.nebiusApiKey
+			const nebiusBaseUrl = apiConfiguration.nebiusBaseUrl || message?.values?.nebiusBaseUrl
+			if (nebiusApiKey && nebiusBaseUrl) {
+				modelFetchPromises.push({
+					key: "nebius",
+					options: { provider: "nebius", apiKey: nebiusApiKey, baseUrl: nebiusBaseUrl },
+				})
+			}
+
 			const results = await Promise.allSettled(
 				modelFetchPromises.map(async ({ key, options }) => {
 					const models = await safeGetModels(options)