@gguf/coder 0.3.0 → 0.3.1

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

@@ -0,0 +1,276 @@
+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
+}

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

@@ -0,0 +1,173 @@
+import test from 'ava';
+import type {StreamCallbacks} from '@/types/index';
+import {createOnStepFinishHandler, createPrepareStepHandler} from './streaming-handler.js';
+import type {TestableMessage} from '../types.js';
+
+test('createOnStepFinishHandler calls onToolExecuted callback', t => {
+	let callbackCalled = false;
+	const callbacks: StreamCallbacks = {
+		onToolExecuted: (toolCall, result) => {
+			callbackCalled = true;
+			t.is(toolCall.function.name, 'test_tool');
+			t.is(result, 'test output');
+		},
+	};
+
+	const handler = createOnStepFinishHandler(callbacks);
+	handler({
+		toolCalls: [
+			{
+				toolCallId: 'call_123',
+				toolName: 'test_tool',
+				input: {},
+			},
+		],
+		toolResults: [
+			{
+				output: 'test output',
+			},
+		],
+	});
+
+	t.true(callbackCalled);
+});
+
+test('createOnStepFinishHandler handles steps without tool calls', t => {
+	const callbacks: StreamCallbacks = {
+		onToolExecuted: () => {
+			t.fail('Should not be called');
+		},
+	};
+
+	const handler = createOnStepFinishHandler(callbacks);
+	handler({
+		text: 'Some text',
+	});
+
+	t.pass();
+});
+
+test('createOnStepFinishHandler handles steps with tool calls but no results', t => {
+	const callbacks: StreamCallbacks = {
+		onToolExecuted: () => {
+			t.fail('Should not be called');
+		},
+	};
+
+	const handler = createOnStepFinishHandler(callbacks);
+	handler({
+		toolCalls: [
+			{
+				toolCallId: 'call_123',
+				toolName: 'test_tool',
+				input: {},
+			},
+		],
+	});
+
+	t.pass();
+});
+
+test('createOnStepFinishHandler converts object output to JSON string', t => {
+	let resultReceived = '';
+	const callbacks: StreamCallbacks = {
+		onToolExecuted: (_toolCall, result) => {
+			resultReceived = result;
+		},
+	};
+
+	const handler = createOnStepFinishHandler(callbacks);
+	handler({
+		toolCalls: [
+			{
+				toolCallId: 'call_123',
+				toolName: 'test_tool',
+				input: {},
+			},
+		],
+		toolResults: [
+			{
+				output: {key: 'value'},
+			},
+		],
+	});
+
+	t.is(resultReceived, '{"key":"value"}');
+});
+
+test('createPrepareStepHandler filters empty assistant messages', t => {
+	const handler = createPrepareStepHandler();
+	const messages = [
+		{role: 'user', content: 'Hello'},
+		{role: 'assistant', content: ''},
+		{role: 'user', content: 'World'},
+	] as unknown as TestableMessage[];
+
+	const result = handler({messages: messages as any});
+
+	t.truthy(result.messages);
+	t.is(result.messages?.length, 2);
+	t.is((result.messages?.[0] as any).content, 'Hello');
+	t.is((result.messages?.[1] as any).content, 'World');
+});
+
+test('createPrepareStepHandler filters orphaned tool messages', t => {
+	const handler = createPrepareStepHandler();
+	const messages = [
+		{role: 'user', content: 'Hello'},
+		{role: 'assistant', content: ''},
+		{role: 'tool', content: 'Tool result'},
+		{role: 'user', content: 'World'},
+	] as unknown as TestableMessage[];
+
+	const result = handler({messages: messages as any});
+
+	t.truthy(result.messages);
+	t.is(result.messages?.length, 2);
+	t.is((result.messages?.[0] as any).content, 'Hello');
+	t.is((result.messages?.[1] as any).content, 'World');
+});
+
+test('createPrepareStepHandler returns empty object when no filtering needed', t => {
+	const handler = createPrepareStepHandler();
+	const messages = [
+		{role: 'user', content: 'Hello'},
+		{role: 'assistant', content: 'Hi'},
+	] as unknown as TestableMessage[];
+
+	const result = handler({messages: messages as any});
+
+	t.deepEqual(result, {});
+});
+
+test('createPrepareStepHandler filters multiple empty assistant messages', t => {
+	const handler = createPrepareStepHandler();
+	const messages = [
+		{role: 'user', content: 'Hello'},
+		{role: 'assistant', content: ''},
+		{role: 'user', content: 'World'},
+		{role: 'assistant', content: '   '},
+		{role: 'user', content: 'Test'},
+	] as unknown as TestableMessage[];
+
+	const result = handler({messages: messages as any});
+
+	t.truthy(result.messages);
+	t.is(result.messages?.length, 3);
+	t.is(result.messages?.[0].role, 'user');
+	t.is(result.messages?.[1].role, 'user');
+	t.is(result.messages?.[2].role, 'user');
+});
+
+test('createPrepareStepHandler keeps non-empty assistant messages', t => {
+	const handler = createPrepareStepHandler();
+	const messages = [
+		{role: 'user', content: 'Hello'},
+		{role: 'assistant', content: 'Response'},
+		{role: 'user', content: 'World'},
+	] as unknown as TestableMessage[];
+
+	const result = handler({messages: messages as any});
+
+	t.deepEqual(result, {});
+});

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

@@ -0,0 +1,110 @@
+import type {StreamCallbacks, ToolCall} from '@/types/index';
+import {getLogger} from '@/utils/logging';
+import type {ModelMessage} from 'ai';
+import {isEmptyAssistantMessage} from '../converters/message-converter.js';
+import {
+	convertAISDKToolCall,
+	getToolResultOutput,
+} from '../converters/tool-converter.js';
+import type {TestableMessage} from '../types.js';
+
+/**
+ * Creates the onStepFinish callback for AI SDK generateText
+ * This handles logging and displaying tool execution results
+ */
+export function createOnStepFinishHandler(callbacks: StreamCallbacks): (step: {
+	toolCalls?: Array<{toolCallId?: string; toolName: string; input: unknown}>;
+	toolResults?: Array<{output: unknown}>;
+	text?: string;
+}) => void {
+	const logger = getLogger();
+
+	return step => {
+		// Log tool execution steps
+		if (step.toolCalls && step.toolCalls.length > 0) {
+			logger.trace('AI SDK tool step', {
+				stepType: 'tool_execution',
+				toolCount: step.toolCalls.length,
+				hasResults: !!step.toolResults,
+			});
+		}
+
+		// Display formatters for auto-executed tools (after execution with results)
+		if (
+			step.toolCalls &&
+			step.toolResults &&
+			step.toolCalls.length === step.toolResults.length
+		) {
+			step.toolCalls.forEach((toolCall, idx) => {
+				const toolResult = step.toolResults?.[idx];
+				if (!toolResult) return;
+				const tc: ToolCall = convertAISDKToolCall(toolCall);
+				const resultStr = getToolResultOutput(toolResult.output);
+
+				logger.debug('Tool executed', {
+					toolName: tc.function.name,
+					resultLength: resultStr.length,
+				});
+
+				callbacks.onToolExecuted?.(tc, resultStr);
+			});
+		}
+	};
+}
+
+/**
+ * Creates the prepareStep callback for AI SDK generateText
+ * This filters out empty assistant messages and orphaned tool results
+ */
+export function createPrepareStepHandler(): (params: {
+	messages: ModelMessage[];
+}) => {messages?: ModelMessage[]} | Record<string, never> {
+	const logger = getLogger();
+
+	return ({messages}) => {
+		// Filter out empty assistant messages that would cause API errors
+		// "Assistant message must have either content or tool_calls"
+		// Also filter out orphaned tool messages that follow empty assistant messages
+		const filteredMessages: ModelMessage[] = [];
+		const indicesToSkip = new Set<number>();
+
+		// First pass: identify empty assistant messages and their orphaned tool results
+		for (let i = 0; i < messages.length; i++) {
+			if (isEmptyAssistantMessage(messages[i] as unknown as TestableMessage)) {
+				indicesToSkip.add(i);
+
+				// Mark any immediately following tool messages as orphaned
+				let j = i + 1;
+				while (j < messages.length && messages[j].role === 'tool') {
+					indicesToSkip.add(j);
+					j++;
+				}
+			}
+		}
+
+		// Second pass: build filtered array
+		for (let i = 0; i < messages.length; i++) {
+			if (!indicesToSkip.has(i)) {
+				filteredMessages.push(messages[i]);
+			}
+		}
+
+		// Log message filtering
+		if (filteredMessages.length !== messages.length) {
+			logger.debug(
+				'Filtered empty assistant messages and orphaned tool results',
+				{
+					originalCount: messages.length,
+					filteredCount: filteredMessages.length,
+					removedCount: messages.length - filteredMessages.length,
+				},
+			);
+		}
+
+		// Return filtered messages if any were removed, otherwise no changes
+		if (filteredMessages.length !== messages.length) {
+			return {messages: filteredMessages};
+		}
+		return {}; // No modifications needed
+	};
+}

package/source/ai-sdk-client/chat/tool-processor.spec.ts

@@ -0,0 +1,92 @@
+import test from 'ava';
+import type {AISDKCoreTool, StreamCallbacks} from '@/types/index';
+import {processXMLToolCalls} from './tool-processor.js';
+
+test('processXMLToolCalls returns empty result when no tools available', t => {
+	const content = 'Some response text';
+	const tools: Record<string, AISDKCoreTool> = {};
+	const callbacks: StreamCallbacks = {};
+
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.deepEqual(result.toolCalls, []);
+	t.is(result.cleanedContent, content);
+});
+
+test('processXMLToolCalls returns empty result when content is empty', t => {
+	const content = '';
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool, // Type-only check, actual structure doesn't matter for empty content test
+	};
+	const callbacks: StreamCallbacks = {};
+
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.deepEqual(result.toolCalls, []);
+	t.is(result.cleanedContent, content);
+});
+
+test('processXMLToolCalls handles malformed XML gracefully', t => {
+	const content = '<tool_call>\n<name>test_tool</name>\n<arguments>';
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool,
+	};
+	const callbacks: StreamCallbacks = {
+		onToolCall: () => {},
+	};
+
+	// Function should not throw, even with malformed XML
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.truthy(result);
+	t.true(Array.isArray(result.toolCalls));
+	t.is(typeof result.cleanedContent, 'string');
+});
+
+test('processXMLToolCalls handles valid XML content', t => {
+	const content =
+		'<tool_call>\n<name>test_tool</name>\n<arguments>{"arg": "value"}</arguments>\n</tool_call>';
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool,
+	};
+
+	const callbacks: StreamCallbacks = {
+		onToolCall: () => {},
+	};
+
+	// Function should not throw with valid XML structure
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.truthy(result);
+	t.true(Array.isArray(result.toolCalls));
+	t.is(typeof result.cleanedContent, 'string');
+});
+
+test('processXMLToolCalls handles mixed content', t => {
+	const content =
+		'Some text before\n<tool_call>\n<name>test_tool</name>\n<arguments>{}</arguments>\n</tool_call>\nSome text after';
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool,
+	};
+	const callbacks: StreamCallbacks = {};
+
+	// Function should not throw with mixed content
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.truthy(result);
+	t.true(Array.isArray(result.toolCalls));
+	t.is(typeof result.cleanedContent, 'string');
+});
+
+test('processXMLToolCalls returns original content when no XML tool calls', t => {
+	const content = 'Just some plain text response';
+	const tools: Record<string, AISDKCoreTool> = {
+		test_tool: {} as AISDKCoreTool,
+	};
+	const callbacks: StreamCallbacks = {};
+
+	const result = processXMLToolCalls(content, tools, callbacks);
+
+	t.deepEqual(result.toolCalls, []);
+	t.is(result.cleanedContent, content);
+});