@gguf/coder 0.3.1 → 0.3.3

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

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

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

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

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

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

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

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