@gguf/coder 0.2.9 → 0.3.1

package/source/model-database/model-database.spec.ts

@@ -0,0 +1,363 @@
+import test from 'ava';
+import {ModelDatabase, modelDatabase} from './model-database';
+import {clearModelCache} from './model-fetcher';
+
+console.log(`\nmodel-database.spec.ts`);
+
+// Note: These tests work with the actual ModelDatabase class behavior.
+// Since we can't mock ES module exports directly, we test the public API
+// and use the global fetch mock where needed.
+
+// Helper to create a fresh instance for each test
+function createFreshInstance(): ModelDatabase {
+	// Create a new instance by bypassing singleton
+	const instance = new (ModelDatabase as any)();
+	return instance;
+}
+
+// Mock models response
+function createMockOpenRouterResponse() {
+	return {
+		data: [
+			{
+				id: 'openai/gpt-4',
+				name: 'GPT-4',
+				description: 'Advanced AI model',
+				created: 1700000000,
+				context_length: 128000,
+				architecture: {
+					modality: 'text',
+					input_modalities: ['text'],
+					output_modalities: ['text'],
+					tokenizer: 'unknown',
+				},
+				pricing: {prompt: '0.00003', completion: '0.00006'},
+				supported_parameters: ['tools'],
+			},
+			{
+				id: 'meta-llama/llama-3.1-70b',
+				name: 'Llama 3.1 70B',
+				description: 'Open source model',
+				created: 1710000000,
+				context_length: 128000,
+				architecture: {
+					modality: 'text',
+					input_modalities: ['text'],
+					output_modalities: ['text'],
+					tokenizer: 'unknown',
+				},
+				pricing: {prompt: '0', completion: '0'},
+				supported_parameters: ['tools'],
+			},
+		],
+	};
+}
+
+test.serial('getInstance returns singleton instance', t => {
+	const instance1 = ModelDatabase.getInstance();
+	const instance2 = ModelDatabase.getInstance();
+	t.is(instance1, instance2);
+});
+
+test.serial('getAllModels returns empty array when no cache', t => {
+	const db = createFreshInstance();
+	// Immediately call getAllModels without any fetch
+	const models = db.getAllModels();
+	t.deepEqual(models, []);
+});
+
+test.serial('clearCache resets cache state', async t => {
+	const db = createFreshInstance();
+
+	// First populate the cache
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		await db.refreshModels();
+		t.true(db.getAllModels().length > 0);
+
+		db.clearCache();
+		// After clear, sync getAllModels should return empty
+		// (but it will trigger a background fetch)
+		const modelsAfterClear = db.getAllModels();
+		t.is(modelsAfterClear.length, 0);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('getAllModelsAsync fetches and returns models', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		const models = await db.getAllModelsAsync();
+		t.true(Array.isArray(models));
+		t.true(models.length > 0);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('refreshModels forces new fetch when cache is cleared', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	let fetchCount = 0;
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		fetchCount++;
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		await db.refreshModels();
+		t.is(fetchCount, 1);
+
+		// Clear global cache to allow re-fetch
+		clearModelCache();
+
+		// Now refresh should fetch again
+		await db.refreshModels();
+		t.is(fetchCount, 2);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('getAllModels returns cached data after async fetch', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		// Fetch data
+		await db.getAllModelsAsync();
+
+		// Now sync call should return cached data
+		const models = db.getAllModels();
+		t.true(models.length > 0);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial(
+	'concurrent getAllModelsAsync calls share the same promise',
+	async t => {
+		const db = createFreshInstance();
+		clearModelCache();
+
+		let fetchCount = 0;
+		const originalFetch = globalThis.fetch;
+		globalThis.fetch = async () => {
+			fetchCount++;
+			// Add small delay to ensure concurrency
+			await new Promise(resolve => setTimeout(resolve, 10));
+			return {
+				ok: true,
+				json: async () => createMockOpenRouterResponse(),
+			} as Response;
+		};
+
+		try {
+			// Start multiple concurrent requests
+			const [result1, result2, result3] = await Promise.all([
+				db.getAllModelsAsync(),
+				db.getAllModelsAsync(),
+				db.getAllModelsAsync(),
+			]);
+
+			// All should succeed
+			t.true(result1.length > 0);
+			t.true(result2.length > 0);
+			t.true(result3.length > 0);
+
+			// Only one fetch should have occurred
+			t.is(fetchCount, 1);
+		} finally {
+			globalThis.fetch = originalFetch;
+			clearModelCache();
+		}
+	},
+);
+
+test.serial('getAllModelsAsync uses cache when fresh', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	let fetchCount = 0;
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		fetchCount++;
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		// First call fetches
+		await db.getAllModelsAsync();
+		t.is(fetchCount, 1);
+
+		// Second call should use cache (within 1 hour TTL)
+		await db.getAllModelsAsync();
+		t.is(fetchCount, 1); // No new fetch
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('refreshModels handles errors', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		throw new Error('Network error');
+	};
+
+	try {
+		// Errors should propagate from refreshModels
+		// The fetcher catches and returns empty array, so refreshModels resolves with []
+		const result = await db.refreshModels();
+		t.deepEqual(result, []);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('getAllModels triggers background fetch when empty', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	let fetchCount = 0;
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		fetchCount++;
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		// Sync call on empty cache returns [] but triggers fetch
+		const immediate = db.getAllModels();
+		t.deepEqual(immediate, []);
+
+		// Wait for background fetch
+		await new Promise(resolve => setTimeout(resolve, 100));
+
+		// Now should have data
+		const afterFetch = db.getAllModels();
+		t.true(afterFetch.length > 0);
+		t.is(fetchCount, 1);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('getAllModels does not trigger multiple fetches', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	let fetchCount = 0;
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		fetchCount++;
+		await new Promise(resolve => setTimeout(resolve, 50));
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		// Multiple sync calls while fetch is in progress
+		db.getAllModels();
+		db.getAllModels();
+		db.getAllModels();
+
+		// Wait for fetch to complete
+		await new Promise(resolve => setTimeout(resolve, 100));
+
+		// Only one fetch should have been triggered
+		t.is(fetchCount, 1);
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});
+
+test.serial('modelDatabase singleton works correctly', t => {
+	// Test the exported singleton instance
+	t.truthy(modelDatabase);
+	t.true(typeof modelDatabase.getAllModels === 'function');
+	t.true(typeof modelDatabase.getAllModelsAsync === 'function');
+	t.true(typeof modelDatabase.refreshModels === 'function');
+	t.true(typeof modelDatabase.clearCache === 'function');
+});
+
+test.serial('models have correct structure after fetch', async t => {
+	const db = createFreshInstance();
+	clearModelCache();
+
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = async () => {
+		return {
+			ok: true,
+			json: async () => createMockOpenRouterResponse(),
+		} as Response;
+	};
+
+	try {
+		const models = await db.getAllModelsAsync();
+		t.true(models.length > 0);
+
+		const model = models[0];
+		t.truthy(model);
+		t.true(typeof model.id === 'string');
+		t.true(typeof model.name === 'string');
+		t.true(typeof model.author === 'string');
+		t.true(typeof model.local === 'boolean');
+		t.true(typeof model.api === 'boolean');
+		t.true(typeof model.contextLength === 'number');
+		t.true(typeof model.hasToolSupport === 'boolean');
+	} finally {
+		globalThis.fetch = originalFetch;
+		clearModelCache();
+	}
+});

package/source/model-database/model-database.ts

@@ -0,0 +1,91 @@
+import {ModelEntry} from '@/types/index';
+import {clearModelCache, fetchModels, isModelsCached} from './model-fetcher';
+
+export class ModelDatabase {
+	private static instance: ModelDatabase;
+	private cachedModels: ModelEntry[] | null = null;
+	private fetchPromise: Promise<ModelEntry[]> | null = null;
+
+	static getInstance(): ModelDatabase {
+		if (!ModelDatabase.instance) {
+			ModelDatabase.instance = new ModelDatabase();
+		}
+		return ModelDatabase.instance;
+	}
+
+	/**
+	 * Get all models - returns cached data if available, empty array otherwise.
+	 * Use getAllModelsAsync() for fetching fresh data.
+	 */
+	getAllModels(): ModelEntry[] {
+		if (this.cachedModels) {
+			return this.cachedModels;
+		}
+
+		// Trigger background fetch if not already in progress
+		if (!this.fetchPromise) {
+			void this.refreshModelsAsync();
+		}
+
+		// Return empty array - caller should use async method for fresh data
+		return [];
+	}
+
+	/**
+	 * Get all models asynchronously - fetches from APIs.
+	 */
+	async getAllModelsAsync(): Promise<ModelEntry[]> {
+		// If we have cached models and they're still fresh, return them
+		if (this.cachedModels && isModelsCached()) {
+			return this.cachedModels;
+		}
+
+		// If fetch is in progress, wait for it
+		if (this.fetchPromise) {
+			return this.fetchPromise;
+		}
+
+		// Start fetch and wait
+		return this.refreshModels();
+	}
+
+	/**
+	 * Force refresh models from APIs
+	 */
+	async refreshModels(): Promise<ModelEntry[]> {
+		this.fetchPromise = fetchModels();
+		try {
+			this.cachedModels = await this.fetchPromise;
+			return this.cachedModels;
+		} finally {
+			this.fetchPromise = null;
+		}
+	}
+
+	/**
+	 * Internal async refresh that doesn't block
+	 */
+	private async refreshModelsAsync(): Promise<void> {
+		if (this.fetchPromise) return;
+
+		this.fetchPromise = fetchModels();
+		try {
+			this.cachedModels = await this.fetchPromise;
+		} catch {
+			// Silently fail - models will be empty
+		} finally {
+			this.fetchPromise = null;
+		}
+	}
+
+	/**
+	 * Clear cache to force fresh fetch on next call
+	 */
+	clearCache(): void {
+		this.cachedModels = null;
+		this.fetchPromise = null;
+		clearModelCache();
+	}
+}
+
+export const modelDatabase = ModelDatabase.getInstance();