@gguf/coder 0.3.1 → 0.3.2

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

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');
-});