@gguf/coder 0.3.0 → 0.3.1

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

@@ -0,0 +1,70 @@
+import {XMLToolCallParser} from '@/tool-calling/xml-parser';
+import type {AISDKCoreTool, StreamCallbacks, ToolCall} from '@/types/index';
+import {getLogger} from '@/utils/logging';
+
+export interface XMLToolProcessingResult {
+	toolCalls: ToolCall[];
+	cleanedContent: string;
+}
+
+/**
+ * Processes XML tool calls from response content
+ */
+export function processXMLToolCalls(
+	content: string,
+	tools: Record<string, AISDKCoreTool>,
+	callbacks: StreamCallbacks,
+): XMLToolProcessingResult {
+	const logger = getLogger();
+	const toolCalls: ToolCall[] = [];
+	let cleanedContent = content;
+
+	// Only process if tools are available and no native tool calls were found
+	if (Object.keys(tools).length === 0 || !content) {
+		return {toolCalls, cleanedContent};
+	}
+
+	logger.debug('Checking for XML tool calls in response content');
+
+	// First check for malformed XML tool calls
+	const malformedError = XMLToolCallParser.detectMalformedToolCall(content);
+	if (malformedError) {
+		logger.warn('Malformed XML tool call detected', {
+			error: malformedError.error,
+		});
+
+		// Return malformed tool call with validation error
+		// This mimics how validators work - returns tool call that will show error
+		const malformedCall: ToolCall = {
+			id: 'malformed_xml_validation',
+			function: {
+				name: '__xml_validation_error__',
+				arguments: {
+					error: malformedError.error,
+				},
+			},
+		};
+		toolCalls.push(malformedCall);
+		callbacks.onToolCall?.(malformedCall);
+		cleanedContent = ''; // Clear content since it was malformed
+	} else if (XMLToolCallParser.hasToolCalls(content)) {
+		logger.debug('Parsing XML tool calls from content');
+
+		// Try to parse well-formed XML tool calls
+		const parsedToolCalls = XMLToolCallParser.parseToolCalls(content);
+		const xmlToolCalls = XMLToolCallParser.convertToToolCalls(parsedToolCalls);
+		cleanedContent = XMLToolCallParser.removeToolCallsFromContent(content);
+
+		logger.debug('XML tool calls parsed', {
+			toolCallCount: xmlToolCalls.length,
+			contentLength: cleanedContent.length,
+		});
+
+		for (const tc of xmlToolCalls) {
+			toolCalls.push(tc);
+			callbacks.onToolCall?.(tc);
+		}
+	}
+
+	return {toolCalls, cleanedContent};
+}

package/source/ai-sdk-client/converters/message-converter.spec.ts

@@ -0,0 +1,220 @@
+import test from 'ava';
+import type {Message} from '@/types/index';
+import {convertToModelMessages, isEmptyAssistantMessage} from './message-converter.js';
+import type {TestableMessage} from '../types.js';
+
+test('isEmptyAssistantMessage returns false for non-assistant messages', t => {
+	const message: TestableMessage = {
+		role: 'user',
+		content: '',
+	};
+	t.false(isEmptyAssistantMessage(message));
+});
+
+test('isEmptyAssistantMessage returns true for empty assistant message with string content', t => {
+	const message: TestableMessage = {
+		role: 'assistant',
+		content: '',
+	};
+	t.true(isEmptyAssistantMessage(message));
+});
+
+test('isEmptyAssistantMessage returns true for empty assistant message with whitespace', t => {
+	const message: TestableMessage = {
+		role: 'assistant',
+		content: '   ',
+	};
+	t.true(isEmptyAssistantMessage(message));
+});
+
+test('isEmptyAssistantMessage returns true for empty assistant message with empty array content', t => {
+	const message: TestableMessage = {
+		role: 'assistant',
+		content: [],
+	};
+	t.true(isEmptyAssistantMessage(message));
+});
+
+test('isEmptyAssistantMessage returns false for assistant message with content', t => {
+	const message: TestableMessage = {
+		role: 'assistant',
+		content: 'Hello',
+	};
+	t.false(isEmptyAssistantMessage(message));
+});
+
+test('isEmptyAssistantMessage returns false for assistant message with tool calls', t => {
+	const message: TestableMessage = {
+		role: 'assistant',
+		content: '',
+		toolCalls: [{name: 'test', arguments: {}}],
+	};
+	t.false(isEmptyAssistantMessage(message));
+});
+
+test('convertToModelMessages converts system message', t => {
+	const messages: Message[] = [
+		{
+			role: 'system',
+			content: 'You are a helpful assistant',
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'system');
+	t.is(result[0].content, 'You are a helpful assistant');
+});
+
+test('convertToModelMessages converts user message', t => {
+	const messages: Message[] = [
+		{
+			role: 'user',
+			content: 'Hello',
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'user');
+	t.is(result[0].content, 'Hello');
+});
+
+test('convertToModelMessages converts assistant message with text', t => {
+	const messages: Message[] = [
+		{
+			role: 'assistant',
+			content: 'Hi there',
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'assistant');
+	t.true(Array.isArray(result[0].content));
+	const content = result[0].content as Array<{type: string; text?: string}>;
+	t.is(content.length, 1);
+	t.is(content[0].type, 'text');
+	t.is(content[0].text, 'Hi there');
+});
+
+test('convertToModelMessages converts assistant message with tool calls', t => {
+	const messages: Message[] = [
+		{
+			role: 'assistant',
+			content: '',
+			tool_calls: [
+				{
+					id: 'call_123',
+					function: {
+						name: 'test_tool',
+						arguments: {arg: 'value'},
+					},
+				},
+			],
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'assistant');
+	t.true(Array.isArray(result[0].content));
+	const content = result[0].content as Array<{
+		type: string;
+		toolCallId?: string;
+		toolName?: string;
+		input?: unknown;
+	}>;
+	t.is(content.length, 1);
+	t.is(content[0].type, 'tool-call');
+	t.is(content[0].toolCallId, 'call_123');
+	t.is(content[0].toolName, 'test_tool');
+	t.deepEqual(content[0].input, {arg: 'value'});
+});
+
+test('convertToModelMessages converts assistant message with both text and tool calls', t => {
+	const messages: Message[] = [
+		{
+			role: 'assistant',
+			content: 'Let me help',
+			tool_calls: [
+				{
+					id: 'call_123',
+					function: {
+						name: 'test_tool',
+						arguments: {},
+					},
+				},
+			],
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'assistant');
+	t.true(Array.isArray(result[0].content));
+	const content = result[0].content as Array<{type: string}>;
+	t.is(content.length, 2);
+	t.is(content[0].type, 'text');
+	t.is(content[1].type, 'tool-call');
+});
+
+test('convertToModelMessages converts empty assistant message to message with empty text', t => {
+	const messages: Message[] = [
+		{
+			role: 'assistant',
+			content: '',
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'assistant');
+	t.true(Array.isArray(result[0].content));
+	const content = result[0].content as Array<{type: string; text?: string}>;
+	t.is(content.length, 1);
+	t.is(content[0].type, 'text');
+	t.is(content[0].text, '');
+});
+
+test('convertToModelMessages converts tool message', t => {
+	const messages: Message[] = [
+		{
+			role: 'tool',
+			content: 'Tool result',
+			tool_call_id: 'call_123',
+			name: 'test_tool',
+		},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 1);
+	t.is(result[0].role, 'tool');
+	t.true(Array.isArray(result[0].content));
+	const content = result[0].content as Array<{
+		type: string;
+		toolCallId?: string;
+		toolName?: string;
+		output?: {type: string; value: string};
+	}>;
+	t.is(content.length, 1);
+	t.is(content[0].type, 'tool-result');
+	t.is(content[0].toolCallId, 'call_123');
+	t.is(content[0].toolName, 'test_tool');
+	t.is(content[0].output?.type, 'text');
+	t.is(content[0].output?.value, 'Tool result');
+});
+
+test('convertToModelMessages handles multiple messages', t => {
+	const messages: Message[] = [
+		{role: 'system', content: 'System'},
+		{role: 'user', content: 'User'},
+		{role: 'assistant', content: 'Assistant'},
+	];
+
+	const result = convertToModelMessages(messages);
+	t.is(result.length, 3);
+	t.is(result[0].role, 'system');
+	t.is(result[1].role, 'user');
+	t.is(result[2].role, 'assistant');
+});

package/source/ai-sdk-client/converters/message-converter.ts

@@ -0,0 +1,113 @@
+import type {Message} from '@/types/index';
+import type {AssistantContent, ModelMessage, TextPart, ToolCallPart} from 'ai';
+import type {TestableMessage} from '../types.js';
+
+/**
+ * Checks if an assistant message is empty (no content and no tool calls).
+ * Empty assistant messages cause API errors:
+ * "400 Bad Request: Assistant message must have either content or tool_calls, but not none."
+ *
+ * Exported for testing purposes.
+ */
+export function isEmptyAssistantMessage(message: TestableMessage): boolean {
+	if (message.role !== 'assistant') {
+		return false;
+	}
+	// Check for content - handle both string and array content formats
+	const hasContent = Array.isArray(message.content)
+		? message.content.length > 0
+		: typeof message.content === 'string' && message.content.trim().length > 0;
+	// Tool calls are in a separate property for AI SDK messages
+	const hasToolCalls =
+		'toolCalls' in message &&
+		Array.isArray(message.toolCalls) &&
+		message.toolCalls.length > 0;
+	return !hasContent && !hasToolCalls;
+}
+
+/**
+ * Convert our Message format to AI SDK v6 ModelMessage format
+ *
+ * Tool messages: Converted to AI SDK tool-result format with proper structure.
+ */
+export function convertToModelMessages(messages: Message[]): ModelMessage[] {
+	return messages.map((msg): ModelMessage => {
+		if (msg.role === 'tool') {
+			// Convert to AI SDK tool-result format
+			// AI SDK expects: { role: 'tool', content: [{ type: 'tool-result', toolCallId, toolName, output }] }
+			// where output is { type: 'text', value: string } or { type: 'json', value: JSONValue }
+			return {
+				role: 'tool',
+				content: [
+					{
+						type: 'tool-result',
+						toolCallId: msg.tool_call_id || '',
+						toolName: msg.name || '',
+						output: {
+							type: 'text',
+							value: msg.content,
+						},
+					},
+				],
+			};
+		}
+
+		if (msg.role === 'system') {
+			return {
+				role: 'system',
+				content: msg.content,
+			};
+		}
+
+		if (msg.role === 'user') {
+			return {
+				role: 'user',
+				content: msg.content,
+			};
+		}
+
+		if (msg.role === 'assistant') {
+			// Build content array
+			const content: AssistantContent = [];
+
+			// Add text content if present
+			if (msg.content) {
+				content.push({
+					type: 'text',
+					text: msg.content,
+				} as TextPart);
+			}
+
+			// Add tool calls if present (for auto-executed messages)
+			if (msg.tool_calls && msg.tool_calls.length > 0) {
+				for (const toolCall of msg.tool_calls) {
+					content.push({
+						type: 'tool-call',
+						toolCallId: toolCall.id,
+						toolName: toolCall.function.name,
+						input: toolCall.function.arguments,
+					} as ToolCallPart);
+				}
+			}
+
+			// If no content at all, add empty text to avoid empty message
+			if (content.length === 0) {
+				content.push({
+					type: 'text',
+					text: '',
+				} as TextPart);
+			}
+
+			return {
+				role: 'assistant',
+				content,
+			};
+		}
+
+		// Fallback - should never happen
+		return {
+			role: 'user',
+			content: msg.content,
+		};
+	});
+}

package/source/ai-sdk-client/converters/tool-converter.spec.ts

@@ -0,0 +1,90 @@
+import test from 'ava';
+import {
+	convertAISDKToolCall,
+	convertAISDKToolCalls,
+	generateToolCallId,
+	getToolResultOutput,
+} from './tool-converter.js';
+
+test('generateToolCallId creates unique IDs', t => {
+	const id1 = generateToolCallId();
+	const id2 = generateToolCallId();
+
+	t.true(id1.startsWith('tool_'));
+	t.true(id2.startsWith('tool_'));
+	t.not(id1, id2);
+});
+
+test('convertAISDKToolCall uses provided toolCallId', t => {
+	const aiToolCall = {
+		toolCallId: 'call_123',
+		toolName: 'test_tool',
+		input: {arg: 'value'},
+	};
+
+	const result = convertAISDKToolCall(aiToolCall);
+
+	t.is(result.id, 'call_123');
+	t.is(result.function.name, 'test_tool');
+	t.deepEqual(result.function.arguments, {arg: 'value'});
+});
+
+test('convertAISDKToolCall generates ID when missing', t => {
+	const aiToolCall = {
+		toolName: 'test_tool',
+		input: {arg: 'value'},
+	};
+
+	const result = convertAISDKToolCall(aiToolCall);
+
+	t.true(result.id.startsWith('tool_'));
+	t.is(result.function.name, 'test_tool');
+	t.deepEqual(result.function.arguments, {arg: 'value'});
+});
+
+test('convertAISDKToolCalls converts multiple tool calls', t => {
+	const aiToolCalls = [
+		{
+			toolCallId: 'call_1',
+			toolName: 'tool_1',
+			input: {a: 1},
+		},
+		{
+			toolName: 'tool_2',
+			input: {b: 2},
+		},
+	];
+
+	const result = convertAISDKToolCalls(aiToolCalls);
+
+	t.is(result.length, 2);
+	t.is(result[0].id, 'call_1');
+	t.is(result[0].function.name, 'tool_1');
+	t.true(result[1].id.startsWith('tool_'));
+	t.is(result[1].function.name, 'tool_2');
+});
+
+test('convertAISDKToolCalls handles empty array', t => {
+	const result = convertAISDKToolCalls([]);
+	t.deepEqual(result, []);
+});
+
+test('getToolResultOutput returns string as-is', t => {
+	const result = getToolResultOutput('test output');
+	t.is(result, 'test output');
+});
+
+test('getToolResultOutput converts object to JSON string', t => {
+	const result = getToolResultOutput({key: 'value'});
+	t.is(result, '{"key":"value"}');
+});
+
+test('getToolResultOutput converts array to JSON string', t => {
+	const result = getToolResultOutput([1, 2, 3]);
+	t.is(result, '[1,2,3]');
+});
+
+test('getToolResultOutput converts number to JSON string', t => {
+	const result = getToolResultOutput(42);
+	t.is(result, '42');
+});

package/source/ai-sdk-client/converters/tool-converter.ts

@@ -0,0 +1,46 @@
+import {randomBytes} from 'node:crypto';
+import type {ToolCall} from '@/types/index';
+
+/**
+ * Generates a unique tool call ID
+ */
+export function generateToolCallId(): string {
+	return `tool_${Date.now()}_${randomBytes(8).toString('hex')}`;
+}
+
+/**
+ * Converts AI SDK tool call format to our ToolCall format
+ */
+export function convertAISDKToolCall(toolCall: {
+	toolCallId?: string;
+	toolName: string;
+	input: unknown;
+}): ToolCall {
+	return {
+		id: toolCall.toolCallId || generateToolCallId(),
+		function: {
+			name: toolCall.toolName,
+			arguments: toolCall.input as Record<string, unknown>,
+		},
+	};
+}
+
+/**
+ * Converts multiple AI SDK tool calls to our ToolCall format
+ */
+export function convertAISDKToolCalls(
+	toolCalls: Array<{
+		toolCallId?: string;
+		toolName: string;
+		input: unknown;
+	}>,
+): ToolCall[] {
+	return toolCalls.map(convertAISDKToolCall);
+}
+
+/**
+ * Gets the tool result output as a string
+ */
+export function getToolResultOutput(output: unknown): string {
+	return typeof output === 'string' ? output : JSON.stringify(output);
+}

package/source/ai-sdk-client/error-handling/error-extractor.spec.ts

@@ -0,0 +1,55 @@
+import test from 'ava';
+import {RetryError} from 'ai';
+import {extractRootError} from './error-extractor.js';
+
+test('extractRootError returns error unchanged if not a RetryError', t => {
+	const error = new Error('Test error');
+	const result = extractRootError(error);
+	t.is(result, error);
+});
+
+test('extractRootError extracts lastError from RetryError', t => {
+	const rootError = new Error('Root cause');
+	const retryError = new RetryError({
+		message: 'Retry failed',
+		reason: 'maxRetriesExceeded',
+		errors: [rootError],
+	});
+
+	const result = extractRootError(retryError);
+	t.is(result, rootError);
+});
+
+test('extractRootError handles nested RetryErrors', t => {
+	const rootError = new Error('Root cause');
+	const innerRetryError = new RetryError({
+		message: 'Inner retry failed',
+		reason: 'maxRetriesExceeded',
+		errors: [rootError],
+	});
+	const outerRetryError = new RetryError({
+		message: 'Outer retry failed',
+		reason: 'maxRetriesExceeded',
+		errors: [innerRetryError],
+	});
+
+	const result = extractRootError(outerRetryError);
+	t.is(result, rootError);
+});
+
+test('extractRootError handles RetryError with no lastError', t => {
+	const retryError = new RetryError({
+		message: 'Retry failed',
+		reason: 'maxRetriesExceeded',
+		errors: [],
+	});
+
+	const result = extractRootError(retryError);
+	t.is(result, retryError);
+});
+
+test('extractRootError handles non-Error values', t => {
+	const nonError = 'string error';
+	const result = extractRootError(nonError);
+	t.is(result, nonError);
+});

package/source/ai-sdk-client/error-handling/error-extractor.ts

@@ -0,0 +1,15 @@
+import {RetryError} from 'ai';
+
+/**
+ * Extracts the root cause error from AI SDK error wrappers.
+ * AI SDK wraps errors in RetryError which contains lastError.
+ */
+export function extractRootError(error: unknown): unknown {
+	// Handle AI SDK RetryError - extract the last error
+	if (RetryError.isInstance(error)) {
+		if (error.lastError) {
+			return extractRootError(error.lastError);
+		}
+	}
+	return error;
+}