fix and update Makehub for PR

Author: ffp5

src/api/providers/fetchers/makehub.ts

@@ -57,55 +57,49 @@ export const getMakehubModels = async (apiKey?: string): Promise<ModelRecord> =>
 		}
 
 		// Add Authorization header if API key is provided
-		if (apiKey) {
-			headers.Authorization = `Bearer ${apiKey}`
+		if (apiKey && apiKey.trim()) {
+			headers.Authorization = `Bearer ${apiKey.trim()}`
 		}
 
 		const response = await axios.get<MakehubModelResponse>(`${MAKEHUB_BASE_URL}/models`, {
 			headers,
-			timeout: 10000,
+			timeout: 15000,
 		})
 
 		if (!response.data?.data) {
-			console.error("Invalid MakeHub API response format:", response.data)
-			return {}
+			console.error("MakeHub: Invalid API response format:", response.data)
+			throw new Error("Invalid API response format from MakeHub")
 		}
 
 		const modelRecord: ModelRecord = {}
 
 		for (const model of response.data.data) {
-			if (!model.model_id || !model.assistant_ready) continue
+			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,
-			})
+			// Validate pricing data
+			if (typeof model.price_per_input_token !== "number" || typeof model.price_per_output_token !== "number") {
+				console.warn(`MakeHub: Invalid pricing for model ${fullModelId}`, {
+					input: model.price_per_input_token,
+					output: model.price_per_output_token,
+				})
+				continue
+			}
 
 			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,
+				inputPrice: model.price_per_input_token,
+				outputPrice: model.price_per_output_token,
 				cacheWritesPrice: model.cache_writes_price,
 				cacheReadsPrice: model.cache_reads_price,
 				description: model.display_name,
@@ -121,11 +115,26 @@ export const getMakehubModels = async (apiKey?: string): Promise<ModelRecord> =>
 
 		return modelRecord
 	} catch (error) {
-		console.error("Error fetching MakeHub models:", error)
+		console.error("MakeHub: Error fetching models:", error)
 		if (axios.isAxiosError(error)) {
-			console.error("Response:", error.response?.data)
-			console.error("Status:", error.response?.status)
+			console.error("MakeHub: HTTP Error Details:", {
+				status: error.response?.status,
+				statusText: error.response?.statusText,
+				data: error.response?.data,
+				hasApiKey: !!apiKey,
+			})
+
+			if (error.response?.status === 401) {
+				throw new Error("MakeHub: Invalid API key. Please check your API key configuration.")
+			} else if (error.response?.status === 403) {
+				throw new Error("MakeHub: Access forbidden. Please check your API key permissions.")
+			} else if (error.response?.status >= 500) {
+				throw new Error("MakeHub: Server error. Please try again later.")
+			} else if (error.code === "ECONNABORTED") {
+				throw new Error("MakeHub: Request timeout. Please check your internet connection.")
+			}
 		}
-		return {}
+
+		throw new Error(`MakeHub: Failed to fetch models - ${error.message || "Unknown error"}`)
 	}
 }

src/api/providers/makehub.ts

@@ -34,8 +34,7 @@ export class MakeHubHandler extends RouterProvider {
 
 	override async *createMessage(systemPrompt: string, messages: Anthropic.Messages.MessageParam[]): ApiStream {
 		this.lastGenerationId = undefined
-		await this.fetchModel()
-		const { id: modelId, info: modelInfo } = this.getModel()
+		const { id: modelId, info: modelInfo } = await this.fetchModel()
 
 		// Convert messages to OpenAI format
 		let openAiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = [
@@ -95,8 +94,6 @@ export class MakeHubHandler extends RouterProvider {
 
 			// Handle usage statistics if present
 			if (!didOutputUsage && chunk.usage) {
-				console.log("MakeHub usage data received:", chunk.usage)
-
 				// Validate token counts to prevent unreasonable values
 				const promptTokens = chunk.usage.prompt_tokens || 0
 				const completionTokens = chunk.usage.completion_tokens || 0
@@ -129,49 +126,40 @@ export class MakeHubHandler extends RouterProvider {
 	 * Calculate cost based on input and output tokens
 	 */
 	private calculateCost(inputTokens: number, outputTokens: number, modelInfo: any): number {
-		// Log the input values for debugging
-		console.log("MakeHub cost calculation inputs:", {
-			inputTokens,
-			outputTokens,
-			modelInfoPrices: {
-				inputPrice: modelInfo.inputPrice,
-				outputPrice: modelInfo.outputPrice,
-			},
-		})
+		// Validate inputs
+		if (!modelInfo || typeof modelInfo.inputPrice !== "number" || typeof modelInfo.outputPrice !== "number") {
+			console.warn("MakeHub: Invalid model pricing information", { modelInfo })
+			return 0
+		}
 
-		// MakeHub API returns prices already in dollars per million tokens,
-		// so we just need to divide tokens by 1,000,000 to get the correct cost
-		const inputCost = (inputTokens / 1_000_000) * (modelInfo.inputPrice || 0)
-		const outputCost = (outputTokens / 1_000_000) * (modelInfo.outputPrice || 0)
-
-		let totalCost = inputCost + outputCost
-
-		// Safety check: If the cost is unreasonably high (over $100),
-		// it's likely there's a calculation error, so apply a scaling factor
-		// This is a temporary fix until we can determine the exact cause
-		if (totalCost > 100) {
-			console.warn("MakeHub cost exceeds $100, applying safety scaling factor")
-			// Apply a scaling factor to bring it to a reasonable range
-			// Assuming a typical conversation shouldn't cost more than a few dollars
-			totalCost = totalCost / 10000
+		if (inputTokens < 0 || outputTokens < 0) {
+			console.warn("MakeHub: Invalid token counts", { inputTokens, outputTokens })
+			return 0
 		}
 
-		// Log the calculated costs for debugging
-		console.log("MakeHub cost calculation result:", {
-			inputTokens: inputTokens,
-			outputTokens: outputTokens,
-			inputPrice: modelInfo.inputPrice,
-			outputPrice: modelInfo.outputPrice,
-			inputCost,
-			outputCost,
-			totalCost,
-		})
+		// MakeHub API returns prices in dollars per million tokens
+		const inputCost = (inputTokens / 1_000_000) * modelInfo.inputPrice
+		const outputCost = (outputTokens / 1_000_000) * modelInfo.outputPrice
+		const totalCost = inputCost + outputCost
+
+		// Log for debugging only if cost seems unusual
+		if (totalCost > 10) {
+			console.log("MakeHub high cost calculation:", {
+				inputTokens,
+				outputTokens,
+				inputPrice: modelInfo.inputPrice,
+				outputPrice: modelInfo.outputPrice,
+				inputCost,
+				outputCost,
+				totalCost,
+			})
+		}
 
-		return totalCost
+		return Math.max(0, totalCost)
 	}
 
 	protected override supportsTemperature(modelId: string): boolean {
-		const model = this.models[modelId]
-		return model?.supportsImages ?? false
+		// Most models support temperature, but exclude o3-mini variants like OpenAI
+		return !modelId.toLowerCase().includes("o3-mini")
 	}
 }

src/core/webview/webviewMessageHandler.ts

@@ -317,9 +317,22 @@ export const webviewMessageHandler = async (provider: ClineProvider, message: We
 				{ key: "requesty", options: { provider: "requesty", apiKey: apiConfiguration.requestyApiKey } },
 				{ key: "glama", options: { provider: "glama" } },
 				{ key: "unbound", options: { provider: "unbound", apiKey: apiConfiguration.unboundApiKey } },
-				{ key: "makehub", options: { provider: "makehub", apiKey: apiConfiguration.makehubApiKey } },
 			]
 
+			// Add MakeHub with proper API key handling
+			if (apiConfiguration.makehubApiKey) {
+				modelFetchPromises.push({
+					key: "makehub",
+					options: { provider: "makehub", apiKey: apiConfiguration.makehubApiKey },
+				})
+			} else {
+				// MakeHub can work without API key, but with limited access
+				modelFetchPromises.push({
+					key: "makehub",
+					options: { provider: "makehub" },
+				})
+			}
+
 			const litellmApiKey = apiConfiguration.litellmApiKey || message?.values?.litellmApiKey
 			const litellmBaseUrl = apiConfiguration.litellmBaseUrl || message?.values?.litellmBaseUrl
 			if (litellmApiKey && litellmBaseUrl) {

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

@@ -402,7 +402,12 @@ const ApiOptions = ({
 			)}
 
 			{selectedProvider === "makehub" && (
-				<MakeHub apiConfiguration={apiConfiguration} setApiConfigurationField={setApiConfigurationField} />
+				<MakeHub
+					apiConfiguration={apiConfiguration}
+					setApiConfigurationField={setApiConfigurationField}
+					routerModels={routerModels}
+					refetchRouterModels={refetchRouterModels}
+				/>
 			)}
 
 			{selectedProvider === "human-relay" && (

webview-ui/src/components/settings/providers/MakeHub.tsx

@@ -39,10 +39,6 @@ export const MakeHub = ({
 
 	const perfRatio = apiConfiguration?.makehubPerfRatio ?? 0.5
 
-	// Get all available models
-	const models = routerModels?.makehub || {}
-	const modelEntries = Object.entries(models).sort(([idA], [idB]) => idA.localeCompare(idB))
-
 	return (
 		<>
 			<VSCodeTextField
@@ -109,8 +105,8 @@ export const MakeHub = ({
 				<VSCodeDropdown
 					value={apiConfiguration?.makehubModelId || makehubDefaultModelId}
 					style={{ width: "100%" }}>
-					{modelEntries.length > 0 ? (
-						modelEntries.map(([id, info]) => (
+					{Object.entries(routerModels?.makehub ?? {}).length > 0 ? (
+						Object.entries(routerModels?.makehub ?? {}).map(([id, info]) => (
 							<VSCodeOption
 								key={id}
 								value={id}
@@ -123,27 +119,30 @@ export const MakeHub = ({
 					)}
 				</VSCodeDropdown>
 
-				{modelEntries.length === 0 && (
+				{Object.entries(routerModels?.makehub ?? {}).length === 0 && (
 					<div className="text-sm text-vscode-descriptionForeground mt-2">
 						{t("settings:providers.noModelsFound", { provider: "MakeHub" })}
 					</div>
 				)}
 
-				{apiConfiguration?.makehubModelId && models[apiConfiguration.makehubModelId] && (
+				{apiConfiguration?.makehubModelId && routerModels?.makehub?.[apiConfiguration.makehubModelId] && (
 					<div className="mt-2 text-sm">
 						<div className="flex justify-between">
 							<span>{t("settings:modelInfo.contextWindow")}:</span>
-							<span>{models[apiConfiguration.makehubModelId].contextWindow.toLocaleString()} tokens</span>
+							<span>
+								{routerModels.makehub[apiConfiguration.makehubModelId].contextWindow.toLocaleString()}{" "}
+								tokens
+							</span>
 						</div>
 						<div className="flex justify-between">
 							<span>{t("settings:modelInfo.inputPrice")}:</span>
-							<span>${models[apiConfiguration.makehubModelId].inputPrice}/M tokens</span>
+							<span>${routerModels.makehub[apiConfiguration.makehubModelId].inputPrice}/M tokens</span>
 						</div>
 						<div className="flex justify-between">
 							<span>{t("settings:modelInfo.outputPrice")}:</span>
-							<span>${models[apiConfiguration.makehubModelId].outputPrice}/M tokens</span>
+							<span>${routerModels.makehub[apiConfiguration.makehubModelId].outputPrice}/M tokens</span>
 						</div>
-						{models[apiConfiguration.makehubModelId].supportsImages && (
+						{routerModels.makehub[apiConfiguration.makehubModelId].supportsImages && (
 							<div className="flex justify-between">
 								<span>{t("settings:modelInfo.supportsImages")}</span>
 								<span>{t("settings:common.yes")}</span>