@gguf/coder 0.3.1 → 0.3.3

package/source/message-handler.ts

@@ -1,67 +0,0 @@
-import type {ToolManager} from '@/tools/tool-manager';
-import type {ToolCall, ToolHandler, ToolResult} from '@/types/index';
-import {formatError} from '@/utils/error-formatter';
-import {parseToolArguments} from '@/utils/tool-args-parser';
-
-// This will be set by the ChatSession
-let toolRegistryGetter: (() => Record<string, ToolHandler>) | null = null;
-
-// This will be set by the App
-let toolManagerGetter: (() => ToolManager | null) | null = null;
-
-export function setToolRegistryGetter(
-	getter: () => Record<string, ToolHandler>,
-) {
-	toolRegistryGetter = getter;
-}
-
-export function setToolManagerGetter(getter: () => ToolManager | null) {
-	toolManagerGetter = getter;
-}
-
-export function getToolManager(): ToolManager | null {
-	return toolManagerGetter ? toolManagerGetter() : null;
-}
-
-export async function processToolUse(toolCall: ToolCall): Promise<ToolResult> {
-	// Handle XML validation errors by throwing (will be caught and returned as error ToolResult)
-	if (toolCall.function.name === '__xml_validation_error__') {
-		const args = toolCall.function.arguments as {error: string};
-		throw new Error(args.error);
-	}
-
-	if (!toolRegistryGetter) {
-		throw new Error('Tool registry not initialized');
-	}
-
-	const toolRegistry = toolRegistryGetter();
-	const handler = toolRegistry[toolCall.function.name];
-	if (!handler) {
-		throw new Error(`Unknown tool: ${toolCall.function.name}`);
-	}
-
-	try {
-		// Parse arguments - use strict mode to throw error on parse failure
-		// Strict mode is required here to catch malformed arguments before tool execution
-		const parsedArgs = parseToolArguments<Record<string, unknown>>(
-			toolCall.function.arguments,
-			{strict: true},
-		);
-		const result = await handler(parsedArgs);
-		return {
-			tool_call_id: toolCall.id,
-			role: 'tool',
-			name: toolCall.function.name,
-			content: result,
-		};
-	} catch (error) {
-		// Convert exceptions to error messages that the model can see and correct
-		const errorMessage = `Error: ${formatError(error)}`;
-		return {
-			tool_call_id: toolCall.id,
-			role: 'tool',
-			name: toolCall.function.name,
-			content: errorMessage,
-		};
-	}
-}

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

@@ -1,494 +0,0 @@
-import {ModelEntry} from '@/types/index';
-import test from 'ava';
-import {DatabaseEngine} from './database-engine';
-import {modelMatchingEngine} from './model-engine';
-
-console.log(`\ndatabase-engine.spec.ts`);
-
-// Create mock models for testing
-function createMockModels(): ModelEntry[] {
-	return [
-		{
-			id: 'openai/gpt-4',
-			name: 'GPT-4',
-			author: 'Openai',
-			size: '128K',
-			local: false,
-			api: true,
-			contextLength: 128000,
-			created: 1700000000,
-			quality: {cost: 5},
-			costType: 'paid',
-			costDetails: '$30.00/M in, $60.00/M out',
-			hasToolSupport: true,
-		},
-		{
-			id: 'anthropic/claude-3-opus',
-			name: 'Claude 3 Opus',
-			author: 'Anthropic',
-			size: '200K',
-			local: false,
-			api: true,
-			contextLength: 200000,
-			created: 1710000000,
-			quality: {cost: 3},
-			costType: 'paid',
-			costDetails: '$15.00/M in, $75.00/M out',
-			hasToolSupport: true,
-		},
-		{
-			id: 'meta-llama/llama-3.1-70b',
-			name: 'Llama 3.1 70B',
-			author: 'Meta-llama',
-			size: '128K',
-			local: true,
-			api: true,
-			contextLength: 128000,
-			created: 1715000000,
-			quality: {cost: 9},
-			costType: 'free',
-			costDetails: 'Free (open weights)',
-			hasToolSupport: true,
-		},
-		{
-			id: 'mistralai/mistral-large',
-			name: 'Mistral Large',
-			author: 'Mistralai',
-			size: '128K',
-			local: true,
-			api: true,
-			contextLength: 128000,
-			created: 1712000000,
-			quality: {cost: 8},
-			costType: 'free',
-			costDetails: 'Free (open weights)',
-			hasToolSupport: true,
-		},
-	];
-}
-
-// Mock ModelResults type
-interface MockModelResults {
-	allModels: ModelEntry[];
-	openModels: ModelEntry[];
-	proprietaryModels: ModelEntry[];
-	latestModels: ModelEntry[];
-}
-
-function createMockModelResults(models: ModelEntry[]): MockModelResults {
-	const openModels = models.filter(m => m.local);
-	const proprietaryModels = models.filter(m => !m.local);
-	const latestModels = [...models].sort((a, b) => b.created - a.created);
-
-	return {
-		allModels: models,
-		openModels,
-		proprietaryModels,
-		latestModels,
-	};
-}
-
-// Helper to create a fresh instance for each test
-function createFreshInstance(): DatabaseEngine {
-	const instance = new (DatabaseEngine as any)();
-	return instance;
-}
-
-test.serial('getInstance returns singleton instance', t => {
-	const instance1 = DatabaseEngine.getInstance();
-	const instance2 = DatabaseEngine.getInstance();
-	t.is(instance1, instance2);
-});
-
-test.serial('getDatabases returns database result structure', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.true(Array.isArray(result.openModels));
-		t.true(Array.isArray(result.proprietaryModels));
-		t.true(Array.isArray(result.latestModels));
-		t.true(Array.isArray(result.allModels));
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabases returns open models correctly', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.openModels.length, 2);
-		t.true(result.openModels.every(m => m.local === true));
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabases returns proprietary models correctly', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.proprietaryModels.length, 2);
-		t.true(result.proprietaryModels.every(m => m.local === false));
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabases returns latest models', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.latestModels.length, mockModels.length);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabases returns all models', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.allModels.length, mockModels.length);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabasesAsync returns database result structure', async t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-	modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-	try {
-		const result = await engine.getDatabasesAsync();
-
-		t.true(Array.isArray(result.openModels));
-		t.true(Array.isArray(result.proprietaryModels));
-		t.true(Array.isArray(result.latestModels));
-		t.true(Array.isArray(result.allModels));
-	} finally {
-		modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-	}
-});
-
-test.serial('getDatabasesAsync returns open models correctly', async t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-	modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-	try {
-		const result = await engine.getDatabasesAsync();
-
-		t.is(result.openModels.length, 2);
-		t.true(result.openModels.every(m => m.local === true));
-	} finally {
-		modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-	}
-});
-
-test.serial(
-	'getDatabasesAsync returns proprietary models correctly',
-	async t => {
-		const engine = createFreshInstance();
-		const mockModels = createMockModels();
-		const mockResults = createMockModelResults(mockModels);
-
-		const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-		modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-		try {
-			const result = await engine.getDatabasesAsync();
-
-			t.is(result.proprietaryModels.length, 2);
-			t.true(result.proprietaryModels.every(m => m.local === false));
-		} finally {
-			modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-		}
-	},
-);
-
-test.serial('getDatabasesAsync returns latest models', async t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-	modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-	try {
-		const result = await engine.getDatabasesAsync();
-
-		t.is(result.latestModels.length, mockModels.length);
-	} finally {
-		modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-	}
-});
-
-test.serial('getDatabasesAsync returns all models', async t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-	modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-	try {
-		const result = await engine.getDatabasesAsync();
-
-		t.is(result.allModels.length, mockModels.length);
-	} finally {
-		modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-	}
-});
-
-test.serial('getDatabases handles empty model list', t => {
-	const engine = createFreshInstance();
-	const mockResults = createMockModelResults([]);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.deepEqual(result.openModels, []);
-		t.deepEqual(result.proprietaryModels, []);
-		t.deepEqual(result.latestModels, []);
-		t.deepEqual(result.allModels, []);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabasesAsync handles empty model list', async t => {
-	const engine = createFreshInstance();
-	const mockResults = createMockModelResults([]);
-
-	const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-	modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-	try {
-		const result = await engine.getDatabasesAsync();
-
-		t.deepEqual(result.openModels, []);
-		t.deepEqual(result.proprietaryModels, []);
-		t.deepEqual(result.latestModels, []);
-		t.deepEqual(result.allModels, []);
-	} finally {
-		modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-	}
-});
-
-test.serial(
-	'getDatabasesAsync handles errors from matching engine',
-	async t => {
-		const engine = createFreshInstance();
-
-		const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-		modelMatchingEngine.getModelsAsync = async () => {
-			throw new Error('Engine error');
-		};
-
-		try {
-			await t.throwsAsync(() => engine.getDatabasesAsync(), {
-				message: 'Engine error',
-			});
-		} finally {
-			modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-		}
-	},
-);
-
-test.serial('getDatabases passes through all model properties', t => {
-	const engine = createFreshInstance();
-	const mockModels = createMockModels();
-	const mockResults = createMockModelResults(mockModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-		const gpt4 = result.allModels.find(m => m.id === 'openai/gpt-4');
-
-		t.truthy(gpt4);
-		t.is(gpt4?.name, 'GPT-4');
-		t.is(gpt4?.author, 'Openai');
-		t.is(gpt4?.size, '128K');
-		t.is(gpt4?.local, false);
-		t.is(gpt4?.api, true);
-		t.is(gpt4?.contextLength, 128000);
-		t.is(gpt4?.quality.cost, 5);
-		t.is(gpt4?.costType, 'paid');
-		t.is(gpt4?.hasToolSupport, true);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial(
-	'getDatabasesAsync passes through all model properties',
-	async t => {
-		const engine = createFreshInstance();
-		const mockModels = createMockModels();
-		const mockResults = createMockModelResults(mockModels);
-
-		const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-		modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-		try {
-			const result = await engine.getDatabasesAsync();
-			const llama = result.allModels.find(
-				m => m.id === 'meta-llama/llama-3.1-70b',
-			);
-
-			t.truthy(llama);
-			t.is(llama?.name, 'Llama 3.1 70B');
-			t.is(llama?.author, 'Meta-llama');
-			t.is(llama?.size, '128K');
-			t.is(llama?.local, true);
-			t.is(llama?.api, true);
-			t.is(llama?.contextLength, 128000);
-			t.is(llama?.quality.cost, 9);
-			t.is(llama?.costType, 'free');
-			t.is(llama?.hasToolSupport, true);
-		} finally {
-			modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-		}
-	},
-);
-
-test.serial(
-	'getDatabases and getDatabasesAsync return equivalent structures',
-	async t => {
-		const engine = createFreshInstance();
-		const mockModels = createMockModels();
-		const mockResults = createMockModelResults(mockModels);
-
-		const originalGetModels = modelMatchingEngine.getModels;
-		const originalGetModelsAsync = modelMatchingEngine.getModelsAsync;
-		modelMatchingEngine.getModels = () => mockResults;
-		modelMatchingEngine.getModelsAsync = async () => mockResults;
-
-		try {
-			const syncResult = engine.getDatabases();
-			const asyncResult = await engine.getDatabasesAsync();
-
-			t.deepEqual(syncResult.openModels, asyncResult.openModels);
-			t.deepEqual(syncResult.proprietaryModels, asyncResult.proprietaryModels);
-			t.deepEqual(syncResult.latestModels, asyncResult.latestModels);
-			t.deepEqual(syncResult.allModels, asyncResult.allModels);
-		} finally {
-			modelMatchingEngine.getModels = originalGetModels;
-			modelMatchingEngine.getModelsAsync = originalGetModelsAsync;
-		}
-	},
-);
-
-test.serial('getDatabases handles only open models', t => {
-	const engine = createFreshInstance();
-	const openOnlyModels: ModelEntry[] = [
-		{
-			id: 'meta-llama/llama-3.1-70b',
-			name: 'Llama 3.1 70B',
-			author: 'Meta-llama',
-			size: '128K',
-			local: true,
-			api: true,
-			contextLength: 128000,
-			created: 1715000000,
-			quality: {cost: 9},
-			costType: 'free',
-			costDetails: 'Free (open weights)',
-			hasToolSupport: true,
-		},
-	];
-	const mockResults = createMockModelResults(openOnlyModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.openModels.length, 1);
-		t.is(result.proprietaryModels.length, 0);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});
-
-test.serial('getDatabases handles only proprietary models', t => {
-	const engine = createFreshInstance();
-	const proprietaryOnlyModels: ModelEntry[] = [
-		{
-			id: 'openai/gpt-4',
-			name: 'GPT-4',
-			author: 'Openai',
-			size: '128K',
-			local: false,
-			api: true,
-			contextLength: 128000,
-			created: 1700000000,
-			quality: {cost: 5},
-			costType: 'paid',
-			costDetails: '$30.00/M in, $60.00/M out',
-			hasToolSupport: true,
-		},
-	];
-	const mockResults = createMockModelResults(proprietaryOnlyModels);
-
-	const originalGetModels = modelMatchingEngine.getModels;
-	modelMatchingEngine.getModels = () => mockResults;
-
-	try {
-		const result = engine.getDatabases();
-
-		t.is(result.openModels.length, 0);
-		t.is(result.proprietaryModels.length, 1);
-	} finally {
-		modelMatchingEngine.getModels = originalGetModels;
-	}
-});

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

@@ -1,50 +0,0 @@
-import {ModelResults, modelMatchingEngine} from '@/model-database/model-engine';
-import {ModelEntry} from '@/types/index';
-
-export interface DatabaseResult {
-	openModels: ModelEntry[];
-	proprietaryModels: ModelEntry[];
-	latestModels: ModelEntry[];
-	allModels: ModelEntry[];
-}
-
-export class DatabaseEngine {
-	private static instance: DatabaseEngine;
-
-	static getInstance(): DatabaseEngine {
-		if (!DatabaseEngine.instance) {
-			DatabaseEngine.instance = new DatabaseEngine();
-		}
-		return DatabaseEngine.instance;
-	}
-
-	/**
-	 * Get model lists (sync - uses cached data)
-	 */
-	getDatabases(): DatabaseResult {
-		const results = modelMatchingEngine.getModels();
-		return this.processResults(results);
-	}
-
-	/**
-	 * Get model lists asynchronously - fetches fresh data
-	 */
-	async getDatabasesAsync(): Promise<DatabaseResult> {
-		const results = await modelMatchingEngine.getModelsAsync();
-		return this.processResults(results);
-	}
-
-	/**
-	 * Process model results into database result
-	 */
-	private processResults(results: ModelResults): DatabaseResult {
-		return {
-			openModels: results.openModels,
-			proprietaryModels: results.proprietaryModels,
-			latestModels: results.latestModels,
-			allModels: results.allModels,
-		};
-	}
-}
-
-export const databaseEngine = DatabaseEngine.getInstance();