@gguf/coder 0.3.1 → 0.3.2

package/source/ai-sdk-client/AISDKClient.spec.ts

@@ -1,117 +0,0 @@
-import test from 'ava';
-import type {AIProviderConfig} from '@/types/index';
-import {AISDKClient} from './AISDKClient.js';
-
-test('AISDKClient constructor initializes with config', t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['test-model-1', 'test-model-2'],
-		config: {
-			baseURL: 'https://api.test.com',
-			apiKey: 'test-key',
-		},
-	};
-
-	const client = new AISDKClient(config);
-
-	t.is(client.getCurrentModel(), 'test-model-1');
-	t.is(client.getContextSize(), 0); // Not yet loaded
-	t.is(client.getMaxRetries(), 2); // Default value
-});
-
-test('AISDKClient.create returns a Promise', async t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['test-model'],
-		config: {
-			baseURL: 'https://api.test.com',
-			apiKey: 'test-key',
-		},
-	};
-
-	const client = await AISDKClient.create(config);
-
-	t.truthy(client);
-	t.true(client instanceof AISDKClient);
-});
-
-test('AISDKClient setModel updates current model', t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['model-1', 'model-2'],
-		config: {
-			baseURL: 'https://api.test.com',
-		},
-	};
-
-	const client = new AISDKClient(config);
-	t.is(client.getCurrentModel(), 'model-1');
-
-	client.setModel('model-2');
-	t.is(client.getCurrentModel(), 'model-2');
-});
-
-test('AISDKClient getAvailableModels returns models array', async t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['model-1', 'model-2', 'model-3'],
-		config: {
-			baseURL: 'https://api.test.com',
-		},
-	};
-
-	const client = new AISDKClient(config);
-	const models = await client.getAvailableModels();
-
-	t.deepEqual(models, ['model-1', 'model-2', 'model-3']);
-});
-
-test('AISDKClient clearContext resolves successfully', async t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['test-model'],
-		config: {
-			baseURL: 'https://api.test.com',
-		},
-	};
-
-	const client = new AISDKClient(config);
-
-	await t.notThrowsAsync(async () => {
-		await client.clearContext();
-	});
-});
-
-test('AISDKClient uses custom maxRetries from config', t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: ['test-model'],
-		maxRetries: 5,
-		config: {
-			baseURL: 'https://api.test.com',
-		},
-	};
-
-	const client = new AISDKClient(config);
-	t.is(client.getMaxRetries(), 5);
-});
-
-test('AISDKClient handles config without models', t => {
-	const config: AIProviderConfig = {
-		name: 'TestProvider',
-		type: 'openai',
-		models: [],
-		config: {
-			baseURL: 'https://api.test.com',
-		},
-	};
-
-	const client = new AISDKClient(config);
-	t.is(client.getCurrentModel(), '');
-});

package/source/ai-sdk-client/AISDKClient.ts

@@ -1,155 +0,0 @@
-import {TIMEOUT_SOCKET_DEFAULT_MS} from '@/constants';
-import {getModelContextLimit} from '@/models/index.js';
-import type {
-	AIProviderConfig,
-	AISDKCoreTool,
-	LLMChatResponse,
-	LLMClient,
-	Message,
-	StreamCallbacks,
-} from '@/types/index';
-import {getLogger} from '@/utils/logging';
-import {createOpenAICompatible} from '@ai-sdk/openai-compatible';
-import type {LanguageModel} from 'ai';
-import {Agent} from 'undici';
-import {handleChat} from './chat/chat-handler.js';
-import {createProvider} from './providers/provider-factory.js';
-
-export class AISDKClient implements LLMClient {
-	private provider: ReturnType<typeof createOpenAICompatible>;
-	private currentModel: string;
-	private availableModels: string[];
-	private providerConfig: AIProviderConfig;
-	private undiciAgent: Agent;
-	private cachedContextSize: number;
-	private maxRetries: number;
-
-	constructor(providerConfig: AIProviderConfig) {
-		const logger = getLogger();
-
-		this.providerConfig = providerConfig;
-		this.availableModels = providerConfig.models;
-		this.currentModel = providerConfig.models[0] || '';
-		this.cachedContextSize = 0;
-		// Default to 2 retries (same as AI SDK default), or use configured value
-		this.maxRetries = providerConfig.maxRetries ?? 2;
-
-		logger.info('AI SDK client initializing', {
-			models: this.availableModels,
-			defaultModel: this.currentModel,
-			provider: providerConfig.name || 'unknown',
-			baseUrl: providerConfig.config.baseURL ? '[REDACTED]' : undefined,
-			maxRetries: this.maxRetries,
-		});
-
-		const {connectionPool} = this.providerConfig;
-		const {requestTimeout, socketTimeout} = this.providerConfig;
-		const effectiveSocketTimeout = socketTimeout ?? requestTimeout;
-		const resolvedSocketTimeout =
-			effectiveSocketTimeout === -1
-				? 0
-				: (effectiveSocketTimeout ?? TIMEOUT_SOCKET_DEFAULT_MS);
-
-		this.undiciAgent = new Agent({
-			connect: {
-				timeout: resolvedSocketTimeout,
-			},
-			bodyTimeout: resolvedSocketTimeout,
-			headersTimeout: resolvedSocketTimeout,
-			keepAliveTimeout: connectionPool?.idleTimeout,
-			keepAliveMaxTimeout: connectionPool?.cumulativeMaxIdleTimeout,
-		});
-
-		this.provider = createProvider(this.providerConfig, this.undiciAgent);
-
-		// Fetch context size asynchronously (don't block construction)
-		void this.updateContextSize();
-	}
-
-	/**
-	 * Fetch and cache context size from models.dev
-	 */
-	private async updateContextSize(): Promise<void> {
-		try {
-			const contextSize = await getModelContextLimit(this.currentModel);
-			this.cachedContextSize = contextSize || 0;
-		} catch {
-			// Silently fail - context size will remain 0
-			this.cachedContextSize = 0;
-		}
-	}
-
-	static create(providerConfig: AIProviderConfig): Promise<AISDKClient> {
-		const client = new AISDKClient(providerConfig);
-		return Promise.resolve(client);
-	}
-
-	setModel(model: string): void {
-		const logger = getLogger();
-		const previousModel = this.currentModel;
-
-		this.currentModel = model;
-
-		logger.info('Model changed', {
-			previousModel,
-			newModel: model,
-			provider: this.providerConfig.name,
-		});
-
-		// Update context size when model changes
-		void this.updateContextSize();
-	}
-
-	getCurrentModel(): string {
-		return this.currentModel;
-	}
-
-	getContextSize(): number {
-		return this.cachedContextSize;
-	}
-
-	getMaxRetries(): number {
-		return this.maxRetries;
-	}
-
-	getAvailableModels(): Promise<string[]> {
-		return Promise.resolve(this.availableModels);
-	}
-
-	/**
-	 * Stream chat with real-time token updates
-	 */
-	async chat(
-		messages: Message[],
-		tools: Record<string, AISDKCoreTool>,
-		callbacks: StreamCallbacks,
-		signal?: AbortSignal,
-	): Promise<LLMChatResponse> {
-		// Get the language model instance from the provider
-		const model = this.provider(this.currentModel) as unknown as LanguageModel;
-
-		// Delegate to chat handler
-		return await handleChat({
-			model,
-			currentModel: this.currentModel,
-			providerConfig: this.providerConfig,
-			messages,
-			tools,
-			callbacks,
-			signal,
-			maxRetries: this.maxRetries,
-		});
-	}
-
-	clearContext(): Promise<void> {
-		const logger = getLogger();
-
-		logger.debug('AI SDK client context cleared', {
-			model: this.currentModel,
-			provider: this.providerConfig.name,
-		});
-
-		// No internal state to clear
-		return Promise.resolve();
-	}
-}

package/source/ai-sdk-client/chat/chat-handler.spec.ts

@@ -1,121 +0,0 @@
-import test from 'ava';
-import type {
-	AIProviderConfig,
-	AISDKCoreTool,
-	Message,
-	StreamCallbacks,
-} from '@/types/index';
-import type {LanguageModel} from 'ai';
-import type {ChatHandlerParams} from './chat-handler.js';
-
-// Note: This file contains basic structure tests
-// Full integration tests would require mocking the AI SDK's generateText function
-// which is complex and better tested through the full AISDKClient
-
-test('ChatHandlerParams has correct structure', t => {
-	const params: ChatHandlerParams = {
-		model: {} as LanguageModel,
-		currentModel: 'test-model',
-		providerConfig: {
-			name: 'TestProvider',
-			type: 'openai',
-			models: ['test-model'],
-			config: {
-				baseURL: 'https://api.test.com',
-				apiKey: 'test-key',
-			},
-		},
-		messages: [],
-		tools: {},
-		callbacks: {},
-		maxRetries: 2,
-	};
-
-	t.is(params.currentModel, 'test-model');
-	t.is(params.providerConfig.name, 'TestProvider');
-	t.deepEqual(params.messages, []);
-	t.deepEqual(params.tools, {});
-});
-
-test('ChatHandlerParams accepts optional signal', t => {
-	const controller = new AbortController();
-	const params: ChatHandlerParams = {
-		model: {} as LanguageModel,
-		currentModel: 'test-model',
-		providerConfig: {
-			name: 'TestProvider',
-			type: 'openai',
-			models: ['test-model'],
-			config: {
-				baseURL: 'https://api.test.com',
-			},
-		},
-		messages: [],
-		tools: {},
-		callbacks: {},
-		signal: controller.signal,
-		maxRetries: 2,
-	};
-
-	t.is(params.signal, controller.signal);
-});
-
-test('ChatHandlerParams accepts messages and tools', t => {
-	const messages: Message[] = [
-		{role: 'user', content: 'Hello'},
-	];
-	const tools: Record<string, AISDKCoreTool> = {
-		test_tool: {} as AISDKCoreTool,
-	};
-
-	const params: ChatHandlerParams = {
-		model: {} as LanguageModel,
-		currentModel: 'test-model',
-		providerConfig: {
-			name: 'TestProvider',
-			type: 'openai',
-			models: ['test-model'],
-			config: {
-				baseURL: 'https://api.test.com',
-			},
-		},
-		messages,
-		tools,
-		callbacks: {},
-		maxRetries: 2,
-	};
-
-	t.is(params.messages.length, 1);
-	t.is(Object.keys(params.tools).length, 1);
-});
-
-test('ChatHandlerParams accepts callbacks', t => {
-	const callbacks: StreamCallbacks = {
-		onToken: () => {},
-		onToolCall: () => {},
-		onToolExecuted: () => {},
-		onFinish: () => {},
-	};
-
-	const params: ChatHandlerParams = {
-		model: {} as LanguageModel,
-		currentModel: 'test-model',
-		providerConfig: {
-			name: 'TestProvider',
-			type: 'openai',
-			models: ['test-model'],
-			config: {
-				baseURL: 'https://api.test.com',
-			},
-		},
-		messages: [],
-		tools: {},
-		callbacks,
-		maxRetries: 2,
-	};
-
-	t.truthy(params.callbacks.onToken);
-	t.truthy(params.callbacks.onToolCall);
-	t.truthy(params.callbacks.onToolExecuted);
-	t.truthy(params.callbacks.onFinish);
-});

package/source/ai-sdk-client/chat/chat-handler.ts

@@ -1,276 +0,0 @@
-import {MAX_TOOL_STEPS} from '@/constants';
-import type {
-	AIProviderConfig,
-	AISDKCoreTool,
-	LLMChatResponse,
-	Message,
-	StreamCallbacks,
-	ToolCall,
-} from '@/types/index';
-import {
-	endMetrics,
-	formatMemoryUsage,
-	generateCorrelationId,
-	getCorrelationId,
-	getLogger,
-	startMetrics,
-	withNewCorrelationContext,
-} from '@/utils/logging';
-import type {LanguageModel} from 'ai';
-import {generateText, stepCountIs} from 'ai';
-import {convertToModelMessages} from '../converters/message-converter.js';
-import {
-	convertAISDKToolCalls,
-	getToolResultOutput,
-} from '../converters/tool-converter.js';
-import {extractRootError} from '../error-handling/error-extractor.js';
-import {parseAPIError} from '../error-handling/error-parser.js';
-import {
-	createOnStepFinishHandler,
-	createPrepareStepHandler,
-} from './streaming-handler.js';
-import {processXMLToolCalls} from './tool-processor.js';
-
-export interface ChatHandlerParams {
-	model: LanguageModel;
-	currentModel: string;
-	providerConfig: AIProviderConfig;
-	messages: Message[];
-	tools: Record<string, AISDKCoreTool>;
-	callbacks: StreamCallbacks;
-	signal?: AbortSignal;
-	maxRetries: number;
-}
-
-/**
- * Main chat handler - orchestrates the entire chat flow
- */
-export async function handleChat(
-	params: ChatHandlerParams,
-): Promise<LLMChatResponse> {
-	const {
-		model,
-		currentModel,
-		providerConfig,
-		messages,
-		tools,
-		callbacks,
-		signal,
-		maxRetries,
-	} = params;
-	const logger = getLogger();
-
-	// Check if already aborted before starting
-	if (signal?.aborted) {
-		logger.debug('Chat request already aborted');
-		throw new Error('Operation was cancelled');
-	}
-
-	// Start performance tracking
-	const metrics = startMetrics();
-	const correlationId = getCorrelationId() || generateCorrelationId();
-
-	logger.info('Chat request starting', {
-		model: currentModel,
-		messageCount: messages.length,
-		toolCount: Object.keys(tools).length,
-		correlationId,
-		provider: providerConfig.name,
-	});
-
-	return await withNewCorrelationContext(async _context => {
-		try {
-			// Tools are already in AI SDK format - use directly
-			const aiTools = Object.keys(tools).length > 0 ? tools : undefined;
-
-			// Convert messages to AI SDK v5 ModelMessage format
-			const modelMessages = convertToModelMessages(messages);
-
-			logger.debug('AI SDK request prepared', {
-				messageCount: modelMessages.length,
-				hasTools: !!aiTools,
-				toolCount: aiTools ? Object.keys(aiTools).length : 0,
-			});
-
-			// Tools with needsApproval: false auto-execute in the loop
-			// Tools with needsApproval: true cause interruptions for manual approval
-			// stopWhen controls when the tool loop stops (max MAX_TOOL_STEPS steps)
-			const result = await generateText({
-				model,
-				messages: modelMessages,
-				tools: aiTools,
-				abortSignal: signal,
-				maxRetries,
-				stopWhen: stepCountIs(MAX_TOOL_STEPS), // Allow up to MAX_TOOL_STEPS tool execution steps
-				// Can be used to add custom logging, metrics, or step tracking
-				onStepFinish: createOnStepFinishHandler(callbacks),
-				prepareStep: createPrepareStepHandler(),
-			});
-
-			// Get the full text from the result
-			const fullText = result.text;
-
-			logger.debug('AI SDK response received', {
-				responseLength: fullText.length,
-				hasToolCalls: !!(result.toolCalls && result.toolCalls.length > 0),
-				toolCallCount: result.toolCalls?.length || 0,
-			});
-
-			// Send the complete text to the callback
-			if (fullText) {
-				callbacks.onToken?.(fullText);
-			}
-
-			// Get tool calls from result
-			const toolCallsResult = result.toolCalls;
-
-			// Extract auto-executed assistant messages and tool results from steps
-			// These need to be added to the messages array so usage tracking can count them
-			const autoExecutedMessages: Array<Message> = [];
-			const steps = result.steps;
-			for (const step of steps) {
-				if (
-					step.toolCalls &&
-					step.toolResults &&
-					step.toolCalls.length === step.toolResults.length
-				) {
-					// This step had tool calls that were auto-executed
-					// Add the assistant message with tool_calls
-					const stepToolCalls: ToolCall[] = convertAISDKToolCalls(
-						step.toolCalls,
-					);
-
-					autoExecutedMessages.push({
-						role: 'assistant',
-						content: step.text || '',
-						tool_calls: stepToolCalls,
-					});
-
-					// Add the tool result messages
-					step.toolCalls.forEach((toolCall, idx) => {
-						const toolResult = step.toolResults[idx];
-						const resultStr = getToolResultOutput(toolResult.output);
-
-						autoExecutedMessages.push({
-							role: 'tool' as const,
-							content: resultStr,
-							tool_call_id:
-								toolCall.toolCallId ||
-								`tool_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`,
-							name: toolCall.toolName,
-						});
-					});
-				}
-			}
-
-			// Extract tool calls
-			const toolCalls: ToolCall[] = [];
-			if (toolCallsResult && toolCallsResult.length > 0) {
-				logger.debug('Processing tool calls from response', {
-					toolCallCount: toolCallsResult.length,
-				});
-
-				for (const toolCall of toolCallsResult) {
-					const tc: ToolCall = convertAISDKToolCalls([toolCall])[0];
-					toolCalls.push(tc);
-
-					logger.debug('Tool call processed', {
-						toolName: tc.function.name,
-						hasArguments: !!tc.function.arguments,
-					});
-
-					// Note: onToolCall already fired in onStepFinish - no need to call again
-				}
-			}
-
-			// Check for XML tool calls if no native ones
-			let content = fullText;
-			const xmlResult = processXMLToolCalls(content, tools, callbacks);
-			if (xmlResult.toolCalls.length > 0) {
-				toolCalls.push(...xmlResult.toolCalls);
-				content = xmlResult.cleanedContent;
-			}
-
-			// Calculate performance metrics
-			const finalMetrics = endMetrics(metrics);
-
-			logger.info('Chat request completed successfully', {
-				model: currentModel,
-				duration: `${finalMetrics.duration.toFixed(2)}ms`,
-				responseLength: content.length,
-				toolCallsFound: toolCalls.length,
-				memoryDelta: formatMemoryUsage(
-					finalMetrics.memoryUsage || process.memoryUsage(),
-				),
-				correlationId,
-				provider: providerConfig.name,
-			});
-
-			callbacks.onFinish?.();
-
-			return {
-				choices: [
-					{
-						message: {
-							role: 'assistant',
-							content,
-							tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
-						},
-					},
-				],
-				// Include auto-executed messages so they can be added to message history
-				autoExecutedMessages:
-					autoExecutedMessages.length > 0 ? autoExecutedMessages : undefined,
-			};
-		} catch (error) {
-			// Calculate performance metrics even for errors
-			const finalMetrics = endMetrics(metrics);
-
-			// Check if this was a user-initiated cancellation
-			if (error instanceof Error && error.name === 'AbortError') {
-				logger.info('Chat request cancelled by user', {
-					model: currentModel,
-					duration: `${finalMetrics.duration.toFixed(2)}ms`,
-					correlationId,
-					provider: providerConfig.name,
-				});
-				throw new Error('Operation was cancelled');
-			}
-
-			// Log the error with performance metrics
-			logger.error('Chat request failed', {
-				model: currentModel,
-				duration: `${finalMetrics.duration.toFixed(2)}ms`,
-				error: error instanceof Error ? error.message : error,
-				errorName: error instanceof Error ? error.name : 'Unknown',
-				correlationId,
-				provider: providerConfig.name,
-				memoryDelta: formatMemoryUsage(
-					finalMetrics.memoryUsage || process.memoryUsage(),
-				),
-			});
-
-			// AI SDK wraps errors in NoOutputGeneratedError with no useful cause
-			// Check if it's a cancellation without an underlying API error
-			if (
-				error instanceof Error &&
-				(error.name === 'AI_NoOutputGeneratedError' ||
-					error.message.includes('No output generated'))
-			) {
-				// Check if there's an underlying RetryError with the real cause
-				const rootError = extractRootError(error);
-				if (rootError === error) {
-					// No underlying error - this is just a cancellation
-					throw new Error('Operation was cancelled');
-				}
-				// There's a real error underneath, parse it
-				const userMessage = parseAPIError(rootError);
-				throw new Error(userMessage);
-			}
-
-			// Parse any other error (including RetryError and APICallError)
-			const userMessage = parseAPIError(error);
-			throw new Error(userMessage);
-		}
-	}, correlationId); // End of withNewCorrelationContext
-}