@gguf/coder 0.2.9 → 0.3.1

package/source/wizard/utils/fetch-cloud-models.spec.ts

@@ -0,0 +1,428 @@
+import test from 'ava';
+import {fetchCloudModels} from './fetch-cloud-models.js';
+
+// Store original fetch for restoration
+const originalFetch = globalThis.fetch;
+
+// Helper to create standard cloud models response (Anthropic, OpenAI, Mistral)
+function createCloudModelsResponse(
+	models: Array<{id: string; name?: string; display_name?: string}>,
+) {
+	return {data: models};
+}
+
+// Helper to create GitHub-style response (direct array)
+function createGitHubResponse(models: Array<{id: string; name: string}>) {
+	return models;
+}
+
+// Helper to create a mock fetch that captures the request
+function createMockFetch(
+	response: unknown,
+	options: {ok?: boolean; status?: number; statusText?: string} = {},
+) {
+	const {ok = true, status = 200, statusText = 'OK'} = options;
+	let capturedUrl: string | undefined;
+	let capturedHeaders: Record<string, string> | undefined;
+
+	const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
+		capturedUrl = url.toString();
+		capturedHeaders = init?.headers as Record<string, string>;
+		return {
+			ok,
+			status,
+			statusText,
+			json: async () => response,
+		} as Response;
+	};
+
+	return {
+		mockFetch,
+		getCapturedUrl: () => capturedUrl,
+		getCapturedHeaders: () => capturedHeaders,
+	};
+}
+
+// Anthropic tests
+test.serial('fetchCloudModels: Anthropic - successful fetch returns models', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'claude-3-opus', display_name: 'Claude 3 Opus'},
+		{id: 'claude-3-sonnet', display_name: 'Claude 3 Sonnet'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('anthropic', 'sk-ant-test-key');
+		t.true(result.success);
+		t.is(result.models.length, 2);
+		t.is(result.error, undefined);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: Anthropic - uses correct endpoint and headers', async t => {
+	const {mockFetch, getCapturedUrl, getCapturedHeaders} = createMockFetch(
+		createCloudModelsResponse([{id: 'model1'}]),
+	);
+	globalThis.fetch = mockFetch;
+
+	try {
+		await fetchCloudModels('anthropic', 'sk-ant-test-key');
+		t.is(getCapturedUrl(), 'https://api.anthropic.com/v1/models');
+		t.is(getCapturedHeaders()?.['X-Api-Key'], 'sk-ant-test-key');
+		t.is(getCapturedHeaders()?.['anthropic-version'], '2023-06-01');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: Anthropic - uses display_name for model name', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'claude-3-opus-20240229', display_name: 'Claude 3 Opus'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('anthropic', 'sk-ant-test-key');
+		t.true(result.success);
+		t.is(result.models[0]?.id, 'claude-3-opus-20240229');
+		t.is(result.models[0]?.name, 'Claude 3 Opus');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// OpenAI tests
+test.serial('fetchCloudModels: OpenAI - successful fetch returns models', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'gpt-4'},
+		{id: 'gpt-3.5-turbo'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'sk-test-key');
+		t.true(result.success);
+		t.is(result.models.length, 2);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: OpenAI - uses correct endpoint and Bearer auth', async t => {
+	const {mockFetch, getCapturedUrl, getCapturedHeaders} = createMockFetch(
+		createCloudModelsResponse([{id: 'model1'}]),
+	);
+	globalThis.fetch = mockFetch;
+
+	try {
+		await fetchCloudModels('openai', 'sk-test-key');
+		t.is(getCapturedUrl(), 'https://api.openai.com/v1/models');
+		t.is(getCapturedHeaders()?.Authorization, 'Bearer sk-test-key');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Mistral tests
+test.serial('fetchCloudModels: Mistral - successful fetch returns models', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'mistral-large'},
+		{id: 'mistral-small'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('mistral', 'test-api-key');
+		t.true(result.success);
+		t.is(result.models.length, 2);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: Mistral - uses correct endpoint and Bearer auth', async t => {
+	const {mockFetch, getCapturedUrl, getCapturedHeaders} = createMockFetch(
+		createCloudModelsResponse([{id: 'model1'}]),
+	);
+	globalThis.fetch = mockFetch;
+
+	try {
+		await fetchCloudModels('mistral', 'test-api-key');
+		t.is(getCapturedUrl(), 'https://api.mistral.ai/v1/models');
+		t.is(getCapturedHeaders()?.Authorization, 'Bearer test-api-key');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// GitHub tests
+test.serial('fetchCloudModels: GitHub - successful fetch returns models', async t => {
+	const response = createGitHubResponse([
+		{id: 'gpt-4o', name: 'GPT-4o'},
+		{id: 'claude-3-5-sonnet', name: 'Claude 3.5 Sonnet'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('github', 'ghp_test-token');
+		t.true(result.success);
+		t.is(result.models.length, 2);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: GitHub - uses correct endpoint and headers', async t => {
+	const {mockFetch, getCapturedUrl, getCapturedHeaders} = createMockFetch(
+		createGitHubResponse([{id: 'model1', name: 'Model 1'}]),
+	);
+	globalThis.fetch = mockFetch;
+
+	try {
+		await fetchCloudModels('github', 'ghp_test-token');
+		t.is(getCapturedUrl(), 'https://models.github.ai/catalog/models');
+		t.is(getCapturedHeaders()?.Authorization, 'Bearer ghp_test-token');
+		t.is(getCapturedHeaders()?.['X-GitHub-Api-Version'], '2022-11-28');
+		t.is(getCapturedHeaders()?.Accept, 'application/vnd.github+json');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: GitHub - uses name field for model name', async t => {
+	const response = createGitHubResponse([{id: 'gpt-4o', name: 'GPT-4o'}]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('github', 'ghp_test-token');
+		t.true(result.success);
+		t.is(result.models[0]?.id, 'gpt-4o');
+		t.is(result.models[0]?.name, 'GPT-4o');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Input validation tests
+test.serial('fetchCloudModels: returns error for empty API key', async t => {
+	const result = await fetchCloudModels('openai', '');
+	t.false(result.success);
+	t.is(result.models.length, 0);
+	t.is(result.error, 'API key is required');
+});
+
+test.serial('fetchCloudModels: returns error for whitespace-only API key', async t => {
+	const result = await fetchCloudModels('openai', '   ');
+	t.false(result.success);
+	t.is(result.models.length, 0);
+	t.is(result.error, 'API key is required');
+});
+
+test.serial('fetchCloudModels: returns error for unknown provider', async t => {
+	// @ts-expect-error Testing invalid provider type
+	const result = await fetchCloudModels('unknown-provider', 'api-key');
+	t.false(result.success);
+	t.is(result.models.length, 0);
+	t.is(result.error, 'Unknown cloud provider: unknown-provider');
+});
+
+// HTTP error tests
+test.serial('fetchCloudModels: returns specific error for 401 Unauthorized', async t => {
+	const {mockFetch} = createMockFetch({}, {ok: false, status: 401, statusText: 'Unauthorized'});
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'invalid-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Invalid API key');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: returns specific error for 403 Forbidden', async t => {
+	const {mockFetch} = createMockFetch({}, {ok: false, status: 403, statusText: 'Forbidden'});
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'restricted-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'API key does not have permission to list models');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: returns generic error for other HTTP errors', async t => {
+	const {mockFetch} = createMockFetch({}, {ok: false, status: 500, statusText: 'Internal Server Error'});
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'API returned 500: Internal Server Error');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Response format validation tests
+test.serial('fetchCloudModels: returns error for invalid response format (non-GitHub)', async t => {
+	const {mockFetch} = createMockFetch({invalid: 'response'}); // Missing data array
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Invalid response format from API');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: returns error for invalid GitHub response format', async t => {
+	const {mockFetch} = createMockFetch({data: []}); // GitHub expects array, not object
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('github', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Invalid response format from API');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: returns error when no models found', async t => {
+	const {mockFetch} = createMockFetch(createCloudModelsResponse([]));
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'No models found for this API key');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Network error tests
+test.serial('fetchCloudModels: handles network error', async t => {
+	globalThis.fetch = async () => {
+		throw new Error('Network error');
+	};
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Network error');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: handles timeout (AbortError)', async t => {
+	globalThis.fetch = async () => {
+		const error = new Error('The operation was aborted');
+		error.name = 'AbortError';
+		throw error;
+	};
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Connection timed out');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+test.serial('fetchCloudModels: handles unknown error type', async t => {
+	globalThis.fetch = async () => {
+		throw 'string error'; // Non-Error thrown
+	};
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.false(result.success);
+		t.is(result.models.length, 0);
+		t.is(result.error, 'Unknown error occurred');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Data validation tests
+test.serial('fetchCloudModels: filters out invalid model entries', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'valid-model'},
+		{id: ''}, // Empty id
+		{id: '   '}, // Whitespace only
+		{} as {id: string}, // Missing id
+		{id: 'another-valid'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.true(result.success);
+		t.is(result.models.length, 2);
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Sorting test
+test.serial('fetchCloudModels: returns models sorted alphabetically by name', async t => {
+	const response = createCloudModelsResponse([
+		{id: 'z-model', display_name: 'Zebra Model'},
+		{id: 'a-model', display_name: 'Alpha Model'},
+		{id: 'm-model', display_name: 'Middle Model'},
+	]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('anthropic', 'api-key');
+		t.true(result.success);
+		t.is(result.models.length, 3);
+		t.is(result.models[0]?.name, 'Alpha Model');
+		t.is(result.models[1]?.name, 'Middle Model');
+		t.is(result.models[2]?.name, 'Zebra Model');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+
+// Fallback to id when no name/display_name
+test.serial('fetchCloudModels: falls back to id when no name or display_name', async t => {
+	const response = createCloudModelsResponse([{id: 'model-id-only'}]);
+	const {mockFetch} = createMockFetch(response);
+	globalThis.fetch = mockFetch;
+
+	try {
+		const result = await fetchCloudModels('openai', 'api-key');
+		t.true(result.success);
+		t.is(result.models[0]?.id, 'model-id-only');
+		t.is(result.models[0]?.name, 'model-id-only');
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});

package/source/wizard/utils/fetch-cloud-models.ts

@@ -0,0 +1,223 @@
+/**
+ * Fetch models from cloud LLM providers
+ * - Anthropic: GET /v1/models with X-Api-Key header
+ * - OpenAI: GET /v1/models with Authorization: Bearer header
+ * - Mistral: GET /v1/models with Authorization: Bearer header
+ * - GitHub: GET /catalog/models with Bearer token and X-GitHub-Api-Version header
+ */
+
+import type {
+	CloudModelsEndpointType,
+	FetchModelsResult,
+	LocalModel,
+} from './fetch-local-models';
+
+interface CloudProviderConfig {
+	endpoint: string;
+	getHeaders: (apiKey: string) => Record<string, string>;
+}
+
+const CLOUD_PROVIDERS: Record<CloudModelsEndpointType, CloudProviderConfig> = {
+	anthropic: {
+		endpoint: 'https://api.anthropic.com/v1/models',
+		getHeaders: apiKey => ({
+			'X-Api-Key': apiKey,
+			'anthropic-version': '2023-06-01',
+			Accept: 'application/json',
+		}),
+	},
+	openai: {
+		endpoint: 'https://api.openai.com/v1/models',
+		getHeaders: apiKey => ({
+			Authorization: `Bearer ${apiKey}`,
+			Accept: 'application/json',
+		}),
+	},
+	mistral: {
+		endpoint: 'https://api.mistral.ai/v1/models',
+		getHeaders: apiKey => ({
+			Authorization: `Bearer ${apiKey}`,
+			Accept: 'application/json',
+		}),
+	},
+	github: {
+		endpoint: 'https://models.github.ai/catalog/models',
+		getHeaders: apiKey => ({
+			Accept: 'application/vnd.github+json',
+			Authorization: `Bearer ${apiKey}`,
+			'X-GitHub-Api-Version': '2022-11-28',
+		}),
+	},
+};
+
+interface CloudModelsResponse {
+	data?: Array<{
+		id: string;
+		name?: string; // GitHub
+		display_name?: string; // Anthropic
+		object?: string; // OpenAI/Mistral
+	}>;
+}
+
+export interface FetchCloudModelsOptions {
+	timeoutMs?: number;
+	debug?: boolean;
+}
+
+/**
+ * Fetch available models from a cloud LLM provider
+ * @param providerType The cloud provider type ('anthropic', 'openai', 'mistral', 'github')
+ * @param apiKey The API key for authentication
+ * @param options Optional settings (timeoutMs, debug)
+ */
+export async function fetchCloudModels(
+	providerType: CloudModelsEndpointType,
+	apiKey: string,
+	options: FetchCloudModelsOptions = {},
+): Promise<FetchModelsResult> {
+	const {timeoutMs = 10000, debug = false} = options;
+
+	const log = (message: string) => {
+		if (debug) {
+			console.log(`[fetch-cloud-models] ${message}`);
+		}
+	};
+
+	const providerConfig = CLOUD_PROVIDERS[providerType];
+	if (!providerConfig) {
+		return {
+			success: false,
+			models: [],
+			error: `Unknown cloud provider: ${providerType}`,
+		};
+	}
+
+	if (!apiKey || !apiKey.trim()) {
+		return {
+			success: false,
+			models: [],
+			error: 'API key is required',
+		};
+	}
+
+	try {
+		log(`Fetching models from ${providerType}: ${providerConfig.endpoint}`);
+
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+		let data: CloudModelsResponse;
+		try {
+			const response = await fetch(providerConfig.endpoint, {
+				method: 'GET',
+				signal: controller.signal,
+				headers: providerConfig.getHeaders(apiKey),
+			});
+
+			if (!response.ok) {
+				log(`Server error: ${response.status} ${response.statusText}`);
+
+				// Provide helpful error messages for common cases
+				if (response.status === 401) {
+					return {
+						success: false,
+						models: [],
+						error: 'Invalid API key',
+					};
+				}
+				if (response.status === 403) {
+					return {
+						success: false,
+						models: [],
+						error: 'API key does not have permission to list models',
+					};
+				}
+
+				return {
+					success: false,
+					models: [],
+					error: `API returned ${response.status}: ${response.statusText}`,
+				};
+			}
+
+			log(`Response OK, parsing JSON...`);
+			data = (await response.json()) as CloudModelsResponse;
+			log(`JSON parsed successfully`);
+		} finally {
+			clearTimeout(timeoutId);
+		}
+
+		// GitHub returns a direct array, others return { data: [...] }
+		type ModelEntry = {id: string; name?: string; display_name?: string};
+		let modelArray: ModelEntry[];
+
+		if (providerType === 'github') {
+			// GitHub returns array directly
+			if (!Array.isArray(data)) {
+				return {
+					success: false,
+					models: [],
+					error: 'Invalid response format from API',
+				};
+			}
+			modelArray = data as unknown as ModelEntry[];
+		} else {
+			// Other providers return { data: [...] }
+			if (!data.data || !Array.isArray(data.data)) {
+				return {
+					success: false,
+					models: [],
+					error: 'Invalid response format from API',
+				};
+			}
+			modelArray = data.data;
+		}
+
+		// Parse models - use name (GitHub) or display_name (Anthropic), otherwise id
+		const models: LocalModel[] = modelArray
+			.filter(m => m && typeof m.id === 'string' && m.id.trim())
+			.map(m => ({
+				id: m.id.trim(),
+				name: m.name || m.display_name || m.id.trim(),
+			}))
+			.sort((a, b) => a.name.localeCompare(b.name));
+
+		log(`Found ${models.length} models (sorted)`);
+
+		if (models.length === 0) {
+			return {
+				success: false,
+				models: [],
+				error: 'No models found for this API key',
+			};
+		}
+
+		return {
+			success: true,
+			models,
+		};
+	} catch (err) {
+		if (err instanceof Error) {
+			if (err.name === 'AbortError') {
+				log(`Request timed out after ${timeoutMs}ms`);
+				return {
+					success: false,
+					models: [],
+					error: 'Connection timed out',
+				};
+			}
+			log(`Error: ${err.message}`);
+			return {
+				success: false,
+				models: [],
+				error: err.message,
+			};
+		}
+		log(`Unknown error occurred`);
+		return {
+			success: false,
+			models: [],
+			error: 'Unknown error occurred',
+		};
+	}
+}