add makehub on roo

Author: ffp5

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -32,6 +32,7 @@ body:
         - Human Relay Provider
         - LiteLLM
         - LM Studio
+        - MakeHub
         - Mistral AI
         - Ollama
         - OpenAI

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

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

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

@@ -25,6 +25,7 @@ export const providerNames = [
 	"human-relay",
 	"fake-ai",
 	"xai",
+	"makehub",
 ] as const
 
 export const providerNamesSchema = z.enum(providerNames)
@@ -478,6 +479,11 @@ const litellmSchema = z.object({
 	litellmModelId: z.string().optional(),
 })
 
+const makehubSchema = z.object({
+	makehubApiKey: z.string().optional(),
+	makehubModelId: z.string().optional(),
+})
+
 const defaultSchema = z.object({
 	apiProvider: z.undefined(),
 })
@@ -589,6 +595,11 @@ export const providerSettingsSchemaDiscriminated = z
 				apiProvider: z.literal("litellm"),
 			}),
 		),
+		makehubSchema.merge(
+			z.object({
+				apiProvider: z.literal("makehub"),
+			}),
+		),
 		defaultSchema,
 	])
 	.and(genericProviderSettingsSchema)
@@ -617,6 +628,7 @@ export const providerSettingsSchema = z.object({
 	...chutesSchema.shape,
 	...litellmSchema.shape,
 	...genericProviderSettingsSchema.shape,
+	...makehubSchema.shape,
 })
 
 export type ProviderSettings = z.infer<typeof providerSettingsSchema>
@@ -716,6 +728,9 @@ const providerSettingsRecord: ProviderSettingsRecord = {
 	litellmBaseUrl: undefined,
 	litellmApiKey: undefined,
 	litellmModelId: undefined,
+	// MakeHub
+	makehubApiKey: undefined,
+	makehubModelId: undefined,
 }
 
 export const PROVIDER_SETTINGS_KEYS = Object.keys(providerSettingsRecord) as Keys<ProviderSettings>[]
@@ -910,6 +925,7 @@ export type SecretState = Pick<
 	| "unboundApiKey"
 	| "requestyApiKey"
 	| "xaiApiKey"
+	| "makehubApiKey"
 >
 
 type SecretStateRecord = Record<Keys<SecretState>, undefined>
@@ -929,6 +945,7 @@ const secretStateRecord: SecretStateRecord = {
 	unboundApiKey: undefined,
 	requestyApiKey: undefined,
 	xaiApiKey: undefined,
+	makehubApiKey: undefined,
 }
 
 export const SECRET_STATE_KEYS = Object.keys(secretStateRecord) as Keys<SecretState>[]

packages/types/src/global-settings.ts

@@ -217,6 +217,7 @@ export type SecretState = Pick<
 	| "groqApiKey"
 	| "chutesApiKey"
 	| "litellmApiKey"
+	| "makehubApiKey"
 	| "codeIndexOpenAiKey"
 	| "codeIndexQdrantApiKey"
 >
@@ -239,6 +240,7 @@ export const SECRET_STATE_KEYS = keysOf<SecretState>()([
 	"groqApiKey",
 	"chutesApiKey",
 	"litellmApiKey",
+	"makehubApiKey",
 	"codeIndexOpenAiKey",
 	"codeIndexQdrantApiKey",
 ])

packages/types/src/provider-settings.ts

@@ -30,6 +30,7 @@ export const providerNames = [
 	"groq",
 	"chutes",
 	"litellm",
+	"makehub",
 ] as const
 
 export const providerNamesSchema = z.enum(providerNames)
@@ -200,6 +201,12 @@ const litellmSchema = baseProviderSettingsSchema.extend({
 	litellmModelId: z.string().optional(),
 })
 
+const makehubSchema = baseProviderSettingsSchema.extend({
+	makehubApiKey: z.string().optional(),
+	makehubModelId: z.string().optional(),
+	makehubPerfRatio: z.number().optional(),
+})
+
 const defaultSchema = z.object({
 	apiProvider: z.undefined(),
 })
@@ -226,6 +233,7 @@ export const providerSettingsSchemaDiscriminated = z.discriminatedUnion("apiProv
 	groqSchema.merge(z.object({ apiProvider: z.literal("groq") })),
 	chutesSchema.merge(z.object({ apiProvider: z.literal("chutes") })),
 	litellmSchema.merge(z.object({ apiProvider: z.literal("litellm") })),
+	makehubSchema.merge(z.object({ apiProvider: z.literal("makehub") })),
 	defaultSchema,
 ])
 
@@ -252,6 +260,7 @@ export const providerSettingsSchema = z.object({
 	...groqSchema.shape,
 	...chutesSchema.shape,
 	...litellmSchema.shape,
+	...makehubSchema.shape,
 	...codebaseIndexProviderSchema.shape,
 })
 
@@ -353,4 +362,8 @@ export const PROVIDER_SETTINGS_KEYS = keysOf<ProviderSettings>()([
 	"litellmBaseUrl",
 	"litellmApiKey",
 	"litellmModelId",
+	// MakeHub
+	"makehubApiKey",
+	"makehubModelId",
+	"makehubPerfRatio",
 ])

src/api/index.ts

@@ -27,6 +27,7 @@ import {
 	GroqHandler,
 	ChutesHandler,
 	LiteLLMHandler,
+	MakeHubHandler,
 } from "./providers"
 
 export interface SingleCompletionHandler {
@@ -106,6 +107,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new ChutesHandler(options)
 		case "litellm":
 			return new LiteLLMHandler(options)
+		case "makehub":
+			return new MakeHubHandler(options)
 		default:
 			return new AnthropicHandler(options)
 	}

src/api/providers/fetchers/makehub.ts

@@ -0,0 +1,131 @@
+import axios from "axios"
+import type { ModelRecord } from "../../../shared/api"
+
+const MAKEHUB_BASE_URL = "https://api.makehub.ai/v1"
+
+interface MakehubModelResponse {
+	data: Array<{
+		context: number
+		model_id: string
+		model_name: string
+		display_name?: string
+		organisation: string
+		price_per_input_token: number
+		price_per_output_token: number
+		provider_name: string
+		quantisation: string | null
+		max_tokens?: number
+		supports_images?: boolean
+		supports_prompt_cache?: boolean
+		cache_writes_price?: number
+		cache_reads_price?: number
+		assistant_ready: boolean
+		providers_available?: string[]
+		thinking_config?: {
+			max_budget?: number
+			output_price?: number
+		}
+		tiers?: Array<{
+			context_window: number
+			input_price?: number
+			output_price?: number
+			cache_writes_price?: number
+			cache_reads_price?: number
+		}>
+		capabilities?: {
+			image_input?: boolean
+			tool_calling?: boolean
+			json_mode?: boolean
+		}
+	}>
+}
+
+/**
+ * Fetches available models from the MakeHub API
+ *
+ * @param apiKey - The API key for authentication
+ * @returns A promise that resolves to a record of model IDs to model info
+ */
+export const getMakehubModels = async (apiKey?: string): Promise<ModelRecord> => {
+	try {
+		// Configure headers based on whether API key is provided
+		const headers: Record<string, string> = {
+			Accept: "application/json",
+			"Content-Type": "application/json",
+			"HTTP-Referer": "vscode.dev",
+			"X-Title": "RooCode",
+		}
+
+		// Add Authorization header if API key is provided
+		if (apiKey) {
+			headers.Authorization = `Bearer ${apiKey}`
+		}
+
+		const response = await axios.get<MakehubModelResponse>(`${MAKEHUB_BASE_URL}/models`, {
+			headers,
+			timeout: 10000,
+		})
+
+		if (!response.data?.data) {
+			console.error("Invalid MakeHub API response format:", response.data)
+			return {}
+		}
+
+		const modelRecord: ModelRecord = {}
+
+		for (const model of response.data.data) {
+			if (!model.model_id || !model.assistant_ready) continue
+
+			// Create a model ID that includes provider information
+			// Use just the model_id as provided by the API, since it already has the proper format
+			const fullModelId = model.model_id.includes("/")
+				? model.model_id // Already has organization format
+				: `${model.organisation}/${model.model_id}` // Add organization prefix
+
+			// Log the raw price values from the API for debugging
+			console.log(`Model ${fullModelId} raw prices:`, {
+				input: model.price_per_input_token,
+				output: model.price_per_output_token,
+			})
+
+			// MakeHub API returns prices already in cost per million tokens,
+			// so we can use them directly without further conversion
+			const inputPrice = model.price_per_input_token
+			const outputPrice = model.price_per_output_token
+
+			console.log(`Model ${fullModelId} stored prices:`, {
+				input: inputPrice,
+				output: outputPrice,
+			})
+
+			modelRecord[fullModelId] = {
+				maxTokens: model.max_tokens ?? undefined,
+				contextWindow: model.context,
+				supportsImages: model.capabilities?.image_input ?? false,
+				supportsComputerUse: model.capabilities?.tool_calling ?? false,
+				supportsPromptCache: model.supports_prompt_cache ?? false,
+				inputPrice: inputPrice,
+				outputPrice: outputPrice,
+				cacheWritesPrice: model.cache_writes_price,
+				cacheReadsPrice: model.cache_reads_price,
+				description: model.display_name,
+				tiers: model.tiers?.map((tier) => ({
+					contextWindow: tier.context_window,
+					inputPrice: tier.input_price,
+					outputPrice: tier.output_price,
+					cacheWritesPrice: tier.cache_writes_price,
+					cacheReadsPrice: tier.cache_reads_price,
+				})),
+			}
+		}
+
+		return modelRecord
+	} catch (error) {
+		console.error("Error fetching MakeHub models:", error)
+		if (axios.isAxiosError(error)) {
+			console.error("Response:", error.response?.data)
+			console.error("Status:", error.response?.status)
+		}
+		return {}
+	}
+}

src/api/providers/fetchers/modelCache.ts

@@ -13,6 +13,7 @@ import { getRequestyModels } from "./requesty"
 import { getGlamaModels } from "./glama"
 import { getUnboundModels } from "./unbound"
 import { getLiteLLMModels } from "./litellm"
+import { getMakehubModels } from "./makehub"
 import { GetModelsOptions } from "../../../shared/api"
 const memoryCache = new NodeCache({ stdTTL: 5 * 60, checkperiod: 5 * 60 })
 
@@ -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 "makehub":
+				// Type safety ensures apiKey is always provided for makehub
+				models = await getMakehubModels(options.apiKey)
+				break
 			default: {
 				// Ensures router is exhaustively checked if RouterName is a strict union
 				const exhaustiveCheck: never = provider

src/api/providers/index.ts

@@ -20,3 +20,4 @@ export { XAIHandler } from "./xai"
 export { GroqHandler } from "./groq"
 export { ChutesHandler } from "./chutes"
 export { LiteLLMHandler } from "./litellm"
+export { MakeHubHandler } from "./makehub"