@gguf/coder 0.3.1 → 0.3.3

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
-}

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

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

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

@@ -1,92 +0,0 @@
-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);
-});