@gguf/coder 0.3.1 → 0.3.3

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

@@ -1,297 +0,0 @@
-import test from 'ava';
-import {fetchLocalModels} from './fetch-local-models.js';
-
-// Store original fetch for restoration
-const originalFetch = globalThis.fetch;
-
-// Helper to create Ollama-style response
-function createOllamaResponse(models: string[]) {
-	return {models: models.map(name => ({name}))};
-}
-
-// Helper to create OpenAI-compatible response
-function createOpenAIResponse(models: string[]) {
-	return {data: models.map(id => ({id}))};
-}
-
-// 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 capturedOptions: RequestInit | undefined;
-
-	const mockFetch = async (url: string | URL | Request, init?: RequestInit) => {
-		capturedUrl = url.toString();
-		capturedOptions = init;
-		return {
-			ok,
-			status,
-			statusText,
-			json: async () => response,
-		} as Response;
-	};
-
-	return {mockFetch, getCapturedUrl: () => capturedUrl, getCapturedOptions: () => capturedOptions};
-}
-
-// Ollama tests
-test.serial('fetchLocalModels: Ollama - successful fetch returns models', async t => {
-	const {mockFetch} = createMockFetch(createOllamaResponse(['llama3:8b', 'mistral:7b']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.true(result.success);
-		t.is(result.models.length, 2);
-		t.is(result.error, undefined);
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: Ollama - uses correct endpoint /api/tags', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOllamaResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.is(getCapturedUrl(), 'http://localhost:11434/api/tags');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: Ollama - strips /v1 suffix before building endpoint', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOllamaResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:11434/v1', 'ollama');
-		t.is(getCapturedUrl(), 'http://localhost:11434/api/tags');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-// OpenAI-compatible tests
-test.serial('fetchLocalModels: OpenAI-compatible - successful fetch returns models', async t => {
-	const {mockFetch} = createMockFetch(createOpenAIResponse(['gpt-4', 'gpt-3.5-turbo']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:1234/v1', 'openai-compatible');
-		t.true(result.success);
-		t.is(result.models.length, 2);
-		t.is(result.error, undefined);
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: OpenAI-compatible - uses /v1/models endpoint when /v1 present', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOpenAIResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:1234/v1', 'openai-compatible');
-		t.is(getCapturedUrl(), 'http://localhost:1234/v1/models');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: OpenAI-compatible - appends /v1/models when no /v1 in path', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOpenAIResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:1234', 'openai-compatible');
-		t.is(getCapturedUrl(), 'http://localhost:1234/v1/models');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: OpenAI-compatible - handles /v1/ in middle of path', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOpenAIResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:1234/v1/chat', 'openai-compatible');
-		t.is(getCapturedUrl(), 'http://localhost:1234/v1/models');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-// URL normalization tests
-test.serial('fetchLocalModels: removes trailing slash from URL', async t => {
-	const {mockFetch, getCapturedUrl} = createMockFetch(createOllamaResponse(['model1']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		await fetchLocalModels('http://localhost:11434/', 'ollama');
-		t.is(getCapturedUrl(), 'http://localhost:11434/api/tags');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-// Error handling tests
-test.serial('fetchLocalModels: returns error on server error response', async t => {
-	const {mockFetch} = createMockFetch({}, {ok: false, status: 500, statusText: 'Internal Server Error'});
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.false(result.success);
-		t.is(result.models.length, 0);
-		t.is(result.error, 'Server returned 500: Internal Server Error');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: returns error when no models found', async t => {
-	const {mockFetch} = createMockFetch(createOllamaResponse([]));
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.false(result.success);
-		t.is(result.models.length, 0);
-		t.is(result.error, 'No models found on the server');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: handles network error', async t => {
-	globalThis.fetch = async () => {
-		throw new Error('Network error');
-	};
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.false(result.success);
-		t.is(result.models.length, 0);
-		t.is(result.error, 'Network error');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: 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 fetchLocalModels('http://localhost:11434', 'ollama');
-		t.false(result.success);
-		t.is(result.models.length, 0);
-		t.is(result.error, 'Connection timed out');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: handles unknown error type', async t => {
-	globalThis.fetch = async () => {
-		throw 'string error'; // Non-Error thrown
-	};
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		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('fetchLocalModels: filters out invalid Ollama model entries', async t => {
-	const invalidResponse = {
-		models: [
-			{name: 'valid-model'},
-			{name: ''}, // Empty name
-			{name: '   '}, // Whitespace only
-			{}, // Missing name
-			null, // Null entry
-			{name: 'another-valid'},
-		],
-	};
-	const {mockFetch} = createMockFetch(invalidResponse);
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.true(result.success);
-		t.is(result.models.length, 2);
-		t.is(result.models[0]?.id, 'another-valid');
-		t.is(result.models[1]?.id, 'valid-model');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-test.serial('fetchLocalModels: filters out invalid OpenAI-compatible model entries', async t => {
-	const invalidResponse = {
-		data: [
-			{id: 'valid-model'},
-			{id: ''}, // Empty id
-			{id: '   '}, // Whitespace only
-			{}, // Missing id
-			null, // Null entry
-			{id: 'another-valid'},
-		],
-	};
-	const {mockFetch} = createMockFetch(invalidResponse);
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:1234/v1', 'openai-compatible');
-		t.true(result.success);
-		t.is(result.models.length, 2);
-		t.is(result.models[0]?.id, 'another-valid');
-		t.is(result.models[1]?.id, 'valid-model');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-// Sorting test
-test.serial('fetchLocalModels: returns models sorted alphabetically', async t => {
-	const {mockFetch} = createMockFetch(createOllamaResponse(['zebra', 'alpha', 'mango']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.true(result.success);
-		t.is(result.models.length, 3);
-		t.is(result.models[0]?.name, 'alpha');
-		t.is(result.models[1]?.name, 'mango');
-		t.is(result.models[2]?.name, 'zebra');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});
-
-// Whitespace trimming test
-test.serial('fetchLocalModels: trims whitespace from model names', async t => {
-	const {mockFetch} = createMockFetch(createOllamaResponse(['  model-with-spaces  ']));
-	globalThis.fetch = mockFetch;
-
-	try {
-		const result = await fetchLocalModels('http://localhost:11434', 'ollama');
-		t.true(result.success);
-		t.is(result.models[0]?.id, 'model-with-spaces');
-		t.is(result.models[0]?.name, 'model-with-spaces');
-	} finally {
-		globalThis.fetch = originalFetch;
-	}
-});

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

@@ -1,192 +0,0 @@
-/**
- * Fetch models from local LLM providers
- * - Ollama: GET /api/tags → { models: [{ name: "llama3:8b" }] }
- * - OpenAI-compatible (LM Studio, llama.cpp): GET /v1/models → { data: [{ id: "model-name" }] }
- */
-
-export interface LocalModel {
-	id: string;
-	name: string;
-}
-
-export type LocalModelsEndpointType = 'ollama' | 'openai-compatible';
-export type CloudModelsEndpointType =
-	| 'anthropic'
-	| 'openai'
-	| 'mistral'
-	| 'github';
-export type ModelsEndpointType =
-	| LocalModelsEndpointType
-	| CloudModelsEndpointType;
-
-interface OllamaResponse {
-	models: Array<{name: string}>;
-}
-
-interface OpenAICompatibleResponse {
-	data: Array<{id: string; object?: string}>;
-}
-
-export interface FetchModelsResult {
-	success: boolean;
-	models: LocalModel[];
-	error?: string;
-}
-
-export interface FetchLocalModelsOptions {
-	timeoutMs?: number;
-	debug?: boolean;
-}
-
-/**
- * Fetch available models from a local LLM provider
- * @param baseUrl The base URL of the provider
- * @param providerType The type of API endpoint ('ollama' or 'openai-compatible')
- * @param options Optional settings (timeoutMs, debug)
- */
-export async function fetchLocalModels(
-	baseUrl: string,
-	providerType: LocalModelsEndpointType,
-	options: FetchLocalModelsOptions = {},
-): Promise<FetchModelsResult> {
-	const {timeoutMs = 2000, debug = false} = options;
-
-	const log = (message: string) => {
-		if (debug) {
-			console.log(`[fetch-local-models] ${message}`);
-		}
-	};
-
-	try {
-		// Normalize the base URL
-		let normalizedUrl = baseUrl.trim();
-		log(`Input URL: ${baseUrl}, Provider type: ${providerType}`);
-		if (normalizedUrl.endsWith('/')) {
-			normalizedUrl = normalizedUrl.slice(0, -1);
-		}
-
-		// Build the endpoint URL based on provider type
-		let endpoint: string;
-		if (providerType === 'ollama') {
-			// Ollama's models endpoint is at /api/tags
-			// If baseUrl contains /v1, we need to strip it for the models endpoint
-			normalizedUrl = normalizedUrl.replace(/\/v1$/, '');
-			endpoint = `${normalizedUrl}/api/tags`;
-		} else {
-			// OpenAI-compatible endpoint is at /v1/models
-			// Ensure we have /v1 in the path (exact match, not /v10, /v1beta, etc.)
-			if (normalizedUrl.endsWith('/v1')) {
-				// Already ends with /v1, use as-is
-				endpoint = `${normalizedUrl}/models`;
-			} else if (normalizedUrl.includes('/v1/')) {
-				// Has /v1/ somewhere in the path - extract base up to and including /v1
-				const v1Index = normalizedUrl.indexOf('/v1/');
-				normalizedUrl = normalizedUrl.substring(0, v1Index + 3); // +3 for '/v1'
-				endpoint = `${normalizedUrl}/models`;
-			} else {
-				// No /v1 in path - append it
-				endpoint = `${normalizedUrl}/v1/models`;
-			}
-		}
-
-		log(`Fetching from endpoint: ${endpoint}`);
-
-		// Create AbortController for timeout
-		const controller = new AbortController();
-		const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
-
-		let data: unknown;
-		try {
-			const response = await fetch(endpoint, {
-				method: 'GET',
-				signal: controller.signal,
-				headers: {
-					Accept: 'application/json',
-				},
-			});
-
-			if (!response.ok) {
-				log(`Server error: ${response.status} ${response.statusText}`);
-				return {
-					success: false,
-					models: [],
-					error: `Server returned ${response.status}: ${response.statusText}`,
-				};
-			}
-
-			log(`Response OK, parsing JSON...`);
-			data = await response.json();
-			log(`JSON parsed successfully`);
-		} finally {
-			// Always clear timeout, even if fetch or JSON parsing throws
-			clearTimeout(timeoutId);
-		}
-
-		let models: LocalModel[] = [];
-
-		if (providerType === 'ollama') {
-			const ollamaData = data as OllamaResponse;
-			if (ollamaData.models && Array.isArray(ollamaData.models)) {
-				// Runtime validation: filter out invalid entries
-				models = ollamaData.models
-					.filter(m => m && typeof m.name === 'string' && m.name.trim())
-					.map(m => ({
-						id: m.name.trim(),
-						name: m.name.trim(),
-					}));
-			}
-		} else {
-			const openaiData = data as OpenAICompatibleResponse;
-			if (openaiData.data && Array.isArray(openaiData.data)) {
-				// Runtime validation: filter out invalid entries
-				models = openaiData.data
-					.filter(m => m && typeof m.id === 'string' && m.id.trim())
-					.map(m => ({
-						id: m.id.trim(),
-						name: m.id.trim(),
-					}));
-			}
-		}
-
-		// Sort models alphabetically
-		models.sort((a, b) => a.name.localeCompare(b.name));
-
-		log(`Found ${models.length} valid models (sorted)`);
-
-		if (models.length === 0) {
-			return {
-				success: false,
-				models: [],
-				error: 'No models found on the server',
-			};
-		}
-
-		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',
-		};
-	}
-}