Add Novita AI provider support

README.md

@@ -86,7 +86,7 @@ for this exact support, so if you are having problems or if you have question, j
 - [简体中文](locales/zh-CN/README.md)
 - [繁體中文](locales/zh-TW/README.md)
 - ...
-  </details>
+      </details>
 
 ---
 

apps/cli/README.md

@@ -78,6 +78,10 @@ By default, the CLI auto-approves actions and runs in interactive TUI mode:
 export OPENROUTER_API_KEY=sk-or-v1-...
 
 roo "What is this project?" -w ~/Documents/my-project
+
+# Or use Novita AI explicitly:
+export NOVITA_API_KEY=...
+roo "What is this project?" --provider novita -w ~/Documents/my-project
 ```
 
 You can also run without a prompt and enter it interactively in TUI mode:
@@ -160,7 +164,7 @@ If you never used Roo Code Router, you can ignore this section entirely.
 | `-d, --debug`                           | Enable debug output (includes detailed debug information, prompts, paths, etc)          | `false`                     |
 | `-a, --require-approval`                | Require manual approval before actions execute                                          | `false`                     |
 | `-k, --api-key <key>`                   | API key for the LLM provider                                                            | From env var                |
-| `--provider <provider>`                 | API provider (anthropic, openai-native, gemini, openrouter, vercel-ai-gateway)          | `openrouter`                |
+| `--provider <provider>`                 | API provider (anthropic, openai-native, gemini, openrouter, novita, vercel-ai-gateway)  | `openrouter`                |
 | `-m, --model <model>`                   | Model to use                                                                            | `anthropic/claude-opus-4.6` |
 | `--mode <mode>`                         | Mode to start in (code, architect, ask, debug, etc.)                                    | `code`                      |
 | `--terminal-shell <path>`               | Absolute shell path for inline terminal command execution                               | Auto-detected shell         |
@@ -186,6 +190,7 @@ The CLI will look for API keys in environment variables if not provided via `--a
 | anthropic         | `ANTHROPIC_API_KEY`         |
 | openai-native     | `OPENAI_API_KEY`            |
 | openrouter        | `OPENROUTER_API_KEY`        |
+| novita            | `NOVITA_API_KEY`            |
 | gemini            | `GOOGLE_API_KEY`            |
 | vercel-ai-gateway | `VERCEL_AI_GATEWAY_API_KEY` |
 
@@ -234,6 +239,9 @@ The CLI will look for API keys in environment variables if not provided via `--a
 # Run directly from source (no build required)
 pnpm dev --provider openrouter --api-key $OPENROUTER_API_KEY --print "Hello"
 
+# Novita AI (OpenAI-compatible)
+pnpm dev --provider novita --api-key $NOVITA_API_KEY --model moonshotai/kimi-k2.7-code --print "Hello"
+
 # Run tests
 pnpm test
 

apps/cli/src/lib/utils/__tests__/provider.test.ts

@@ -1,4 +1,4 @@
-import { getApiKeyFromEnv } from "../provider.js"
+import { getApiKeyFromEnv, getProviderSettings } from "../provider.js"
 
 describe("getApiKeyFromEnv", () => {
 	const originalEnv = process.env
@@ -22,6 +22,11 @@ describe("getApiKeyFromEnv", () => {
 		expect(getApiKeyFromEnv("openrouter")).toBe("test-openrouter-key")
 	})
 
+	it("should return API key from environment variable for novita", () => {
+		process.env.NOVITA_API_KEY = "test-novita-key"
+		expect(getApiKeyFromEnv("novita")).toBe("test-novita-key")
+	})
+
 	it("should return API key from environment variable for openai", () => {
 		process.env.OPENAI_API_KEY = "test-openai-key"
 		expect(getApiKeyFromEnv("openai-native")).toBe("test-openai-key")
@@ -32,3 +37,13 @@ describe("getApiKeyFromEnv", () => {
 		expect(getApiKeyFromEnv("anthropic")).toBeUndefined()
 	})
 })
+
+describe("getProviderSettings", () => {
+	it("should map Novita key and model into provider settings", () => {
+		expect(getProviderSettings("novita", "test-novita-key", "moonshotai/kimi-k2.7-code")).toEqual({
+			apiProvider: "novita",
+			novitaApiKey: "test-novita-key",
+			apiModelId: "moonshotai/kimi-k2.7-code",
+		})
+	})
+})

apps/cli/src/lib/utils/provider.ts

@@ -7,6 +7,7 @@ const envVarMap: Record<SupportedProvider, string> = {
 	"openai-native": "OPENAI_API_KEY",
 	gemini: "GOOGLE_API_KEY",
 	openrouter: "OPENROUTER_API_KEY",
+	novita: "NOVITA_API_KEY",
 	"vercel-ai-gateway": "VERCEL_AI_GATEWAY_API_KEY",
 }
 
@@ -43,6 +44,10 @@ export function getProviderSettings(
 			if (apiKey) config.openRouterApiKey = apiKey
 			if (model) config.openRouterModelId = model
 			break
+		case "novita":
+			if (apiKey) config.novitaApiKey = apiKey
+			if (model) config.apiModelId = model
+			break
 		case "vercel-ai-gateway":
 			if (apiKey) config.vercelAiGatewayApiKey = apiKey
 			if (model) config.vercelAiGatewayModelId = model

apps/cli/src/types/types.ts

@@ -6,6 +6,7 @@ export const supportedProviders = [
 	"openai-native",
 	"gemini",
 	"openrouter",
+	"novita",
 	"vercel-ai-gateway",
 ] as const satisfies ProviderName[]
 

apps/vscode-e2e/AGENTS.md

@@ -229,6 +229,25 @@ After converting the generated `openai-*.json` files into stable named fixtures,
 USE_MOCK=true TEST_FILE=deepseek-v4.test pnpm --filter @roo-code/vscode-e2e test:run
 ```
 
+### Novita AI (`suite/providers/novita.test.ts`)
+
+Novita exposes an OpenAI-compatible endpoint, so the suite redirects the provider through aimock with
+`novitaBaseUrl: ${AIMOCK_URL}/v1`. The default model is `moonshotai/kimi-k2.7-code`; override it with
+`NOVITA_MODEL_ID` only when refreshing matching fixtures.
+
+Record Novita fixtures with the targeted file filter so aimock proxies OpenAI-compatible traffic to
+`https://api.novita.ai/openai`:
+
+```sh
+NOVITA_API_KEY=<key> TEST_FILE=novita.test pnpm --filter @roo-code/vscode-e2e test:record
+```
+
+After converting generated `openai-*.json` files into `fixtures/novita.json`, verify in mock mode:
+
+```sh
+USE_MOCK=true TEST_FILE=novita.test pnpm --filter @roo-code/vscode-e2e test:run
+```
+
 ## Tests that use a non-default provider
 
 If your test calls `api.setConfiguration({ apiProvider: "anthropic", ... })`, point aimock at the

apps/vscode-e2e/eslint.config.mjs

@@ -1,4 +1,12 @@
 import { config } from "@roo-code/config-eslint/base"
 
 /** @type {import("eslint").Linter.Config} */
-export default [...config]
+export default [
+	...config,
+	{
+		files: ["**/*.d.ts"],
+		rules: {
+			"no-var": "off",
+		},
+	},
+]

apps/vscode-e2e/fixtures/novita.json

@@ -0,0 +1,20 @@
+{
+	"fixtures": [
+		{
+			"match": {
+				"model": "moonshotai/kimi-k2.7-code",
+				"userMessage": "[ERROR] You did not use a tool in your previous response!",
+				"sequenceIndex": 0
+			},
+			"response": {
+				"toolCalls": [
+					{
+						"name": "attempt_completion",
+						"arguments": "{\"result\":\"NOVITA_E2E_MARKER\"}",
+						"id": "call_novita_retry_done"
+					}
+				]
+			}
+		}
+	]
+}

apps/vscode-e2e/src/fixtures/novita.ts

@@ -0,0 +1,54 @@
+import { LLMock, type ChatCompletionRequest } from "@copilotkit/aimock"
+
+function requestIncludes(req: ChatCompletionRequest, text: string) {
+	const messages = Array.isArray(req?.messages) ? req.messages : []
+
+	return JSON.stringify(messages).includes(text)
+}
+
+function isInitialNovitaToolProbe(req: ChatCompletionRequest) {
+	return (
+		requestIncludes(req, "novita-e2e:tool-use") &&
+		!requestIncludes(req, "call_novita_read") &&
+		!requestIncludes(req, "NOVITA_E2E_MARKER") &&
+		!requestIncludes(req, "[ERROR] You did not use a tool in your previous response!")
+	)
+}
+
+function hasNovitaReadFileResult(req: ChatCompletionRequest) {
+	return requestIncludes(req, "novita-e2e:tool-use") && !isInitialNovitaToolProbe(req)
+}
+
+export function addNovitaFixtures(mock: InstanceType<typeof LLMock>) {
+	mock.addFixture({
+		match: {
+			model: "moonshotai/kimi-k2.7-code",
+			predicate: hasNovitaReadFileResult,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "attempt_completion",
+					arguments: JSON.stringify({ result: "NOVITA_E2E_MARKER" }),
+					id: "call_novita_done",
+				},
+			],
+		},
+	})
+
+	mock.addFixture({
+		match: {
+			model: "moonshotai/kimi-k2.7-code",
+			predicate: isInitialNovitaToolProbe,
+		},
+		response: {
+			toolCalls: [
+				{
+					name: "read_file",
+					arguments: JSON.stringify({ path: "novita-e2e-marker.txt" }),
+					id: "call_novita_read",
+				},
+			],
+		},
+	})
+}

apps/vscode-e2e/src/runTest.ts

@@ -15,6 +15,7 @@ import { addSearchFilesResultFixtures } from "./fixtures/search-files"
 import { addSubtaskFixtures } from "./fixtures/subtasks"
 import { addUseMcpToolResultFixtures } from "./fixtures/use-mcp-tool"
 import { addWriteToFileResultFixtures } from "./fixtures/write-to-file"
+import { addNovitaFixtures } from "./fixtures/novita"
 
 function getCliFlagValue(flag: string) {
 	return process.argv.find((arg, index) => process.argv[index - 1] === flag)
@@ -29,6 +30,14 @@ function isDeepSeekTargetedRun(testFile?: string, testGrep?: string) {
 	return testGrep?.toLowerCase().includes("deepseek") ?? false
 }
 
+function isNovitaTargetedRun(testFile?: string, testGrep?: string) {
+	if (testFile?.toLowerCase().includes("novita.test")) {
+		return true
+	}
+
+	return testGrep?.toLowerCase().includes("novita") ?? false
+}
+
 function isBedrockTargetedRun(testFile?: string, testGrep?: string) {
 	if (testFile?.toLowerCase().includes("bedrock.test")) {
 		return true
@@ -42,28 +51,35 @@ async function main() {
 	const testGrep = getCliFlagValue("--grep") || process.env.TEST_GREP
 	const testFile = getCliFlagValue("--file") || process.env.TEST_FILE
 	const isDeepSeekTest = isDeepSeekTargetedRun(testFile, testGrep)
+	const isNovitaTest = isNovitaTargetedRun(testFile, testGrep)
 	const isGeminiTest = testFile?.toLowerCase().includes("gemini.test") ?? false
 	const isBedrockTest = isBedrockTargetedRun(testFile, testGrep)
 
 	if (isRecord && isDeepSeekTest && !process.env.DEEPSEEK_API_KEY) {
 		throw new Error("AIMOCK_RECORD=true requires DEEPSEEK_API_KEY to record DeepSeek fixtures")
 	}
 
+	if (isRecord && isNovitaTest && !process.env.NOVITA_API_KEY) {
+		throw new Error("AIMOCK_RECORD=true requires NOVITA_API_KEY to record Novita fixtures")
+	}
+
 	if (isRecord && isGeminiTest && !process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) {
 		throw new Error("AIMOCK_RECORD=true requires GEMINI_API_KEY to record Gemini fixtures")
 	}
 
-	if (isRecord && !isDeepSeekTest && !isGeminiTest && !process.env.OPENROUTER_API_KEY) {
+	if (isRecord && !isDeepSeekTest && !isNovitaTest && !isGeminiTest && !process.env.OPENROUTER_API_KEY) {
 		throw new Error("AIMOCK_RECORD=true requires OPENROUTER_API_KEY to record fixtures")
 	}
 
 	// Record mode always needs aimock running (to capture traffic).
 	// Replay mode starts aimock when no real API key is present or USE_MOCK is forced.
 	const hasRealApiKey = isDeepSeekTest
 		? !!process.env.DEEPSEEK_API_KEY
-		: isBedrockTest
-			? true // Bedrock test starts its own binary-event-stream mock server when no real token
-			: !!(process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY)
+		: isNovitaTest
+			? !!process.env.NOVITA_API_KEY
+			: isBedrockTest
+				? true // Bedrock test starts its own binary-event-stream mock server when no real token
+				: !!(process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY)
 	const useMock = isRecord || !hasRealApiKey || process.env.USE_MOCK === "true"
 
 	let mock: InstanceType<typeof LLMock> | undefined
@@ -94,7 +110,11 @@ async function main() {
 						// Use /api (not /api/v1) — aimock appends the request path (/v1/chat/completions)
 						// so including /v1 here would produce a doubled /v1/v1 upstream URL.
 						providers: {
-							openai: isDeepSeekTest ? "https://api.deepseek.com" : "https://openrouter.ai/api",
+							openai: isDeepSeekTest
+								? "https://api.deepseek.com"
+								: isNovitaTest
+									? "https://api.novita.ai/openai"
+									: "https://openrouter.ai/api",
 							// aimock forwards the x-api-key header from the Anthropic SDK to the real API.
 							anthropic: "https://api.anthropic.com",
 							// aimock forwards the x-goog-api-key header from the Google AI SDK.
@@ -117,6 +137,7 @@ async function main() {
 				addSubtaskFixtures(mock)
 				addUseMcpToolResultFixtures(mock)
 				addWriteToFileResultFixtures(mock)
+				addNovitaFixtures(mock)
 
 				// The modes test (switch_mode → ask) triggers a second API call whose last
 				// user message starts with <environment_details> directly — no <user_message>