@gguf/coder 0.3.0 → 0.3.1

package/source/hooks/chat-handler/conversation/conversation-loop.tsx

@@ -0,0 +1,511 @@
+import type {ConversationStateManager} from '@/app/utils/conversationState';
+import AssistantMessage from '@/components/assistant-message';
+import {ErrorMessage} from '@/components/message-box';
+import UserMessage from '@/components/user-message';
+import {parseToolCalls} from '@/tool-calling/index';
+import type {ToolManager} from '@/tools/tool-manager';
+import type {LLMClient, Message, ToolCall, ToolResult} from '@/types/core';
+import {MessageBuilder} from '@/utils/message-builder';
+import {parseToolArguments} from '@/utils/tool-args-parser';
+import {displayToolResult} from '@/utils/tool-result-display';
+import type React from 'react';
+import {filterValidToolCalls} from '../utils/tool-filters';
+import {executeToolsDirectly} from './tool-executor';
+
+interface ProcessAssistantResponseParams {
+	systemMessage: Message;
+	messages: Message[];
+	client: LLMClient;
+	toolManager: ToolManager | null;
+	abortController: AbortController | null;
+	setAbortController: (controller: AbortController | null) => void;
+	setIsGenerating: (generating: boolean) => void;
+	setStreamingContent: (content: string) => void;
+	setTokenCount: (count: number) => void;
+	setMessages: (messages: Message[]) => void;
+	addToChatQueue: (component: React.ReactNode) => void;
+	componentKeyCounter: number;
+	currentModel: string;
+	developmentMode: 'normal' | 'auto-accept' | 'plan';
+	nonInteractiveMode: boolean;
+	conversationStateManager: React.MutableRefObject<ConversationStateManager>;
+	onStartToolConfirmationFlow: (
+		toolCalls: ToolCall[],
+		updatedMessages: Message[],
+		assistantMsg: Message,
+		systemMessage: Message,
+	) => void;
+	onConversationComplete?: () => void;
+}
+
+/**
+ * Main conversation loop that processes assistant responses and handles tool calls.
+ * This function orchestrates the entire conversation flow including:
+ * - Streaming responses from the LLM
+ * - Parsing and validating tool calls
+ * - Executing or requesting confirmation for tools
+ * - Handling errors and self-correction
+ * - Managing the conversation state
+ */
+export const processAssistantResponse = async (
+	params: ProcessAssistantResponseParams,
+): Promise<void> => {
+	const {
+		systemMessage,
+		messages,
+		client,
+		toolManager,
+		abortController,
+		setAbortController,
+		setIsGenerating,
+		setStreamingContent,
+		setTokenCount,
+		setMessages,
+		addToChatQueue,
+		componentKeyCounter,
+		currentModel,
+		developmentMode,
+		nonInteractiveMode,
+		conversationStateManager,
+		onStartToolConfirmationFlow,
+		onConversationComplete,
+	} = params;
+
+	// Ensure we have an abort controller for this request
+	let controller = abortController;
+	if (!controller) {
+		controller = new AbortController();
+		setAbortController(controller);
+	}
+
+	// Use streaming with callbacks
+	setIsGenerating(true);
+	setStreamingContent('');
+	setTokenCount(0);
+
+	const result = await client.chat(
+		[systemMessage, ...messages],
+		toolManager?.getAllTools() || {},
+		{
+			onToolExecuted: (toolCall: ToolCall, result: string) => {
+				// Display formatter for auto-executed tools (after execution with results)
+				void (async () => {
+					const toolResult: ToolResult = {
+						tool_call_id: toolCall.id,
+						role: 'tool' as const,
+						name: toolCall.function.name,
+						content: result,
+					};
+					await displayToolResult(
+						toolCall,
+						toolResult,
+						toolManager,
+						addToChatQueue,
+						componentKeyCounter,
+					);
+				})();
+			},
+			onFinish: () => {
+				setIsGenerating(false);
+			},
+		},
+		controller.signal,
+	);
+
+	if (!result || !result.choices || result.choices.length === 0) {
+		throw new Error('No response received from model');
+	}
+
+	const message = result.choices[0].message;
+	const toolCalls = message.tool_calls || null;
+	const fullContent = message.content || '';
+
+	// Parse any tool calls from content for non-tool-calling models
+	const parseResult = parseToolCalls(fullContent);
+
+	// Check for malformed tool calls and send error back to model for self-correction
+	if (!parseResult.success) {
+		const errorContent = `${parseResult.error}\n\n${parseResult.examples}`;
+
+		// Display error to user
+		addToChatQueue(
+			<ErrorMessage
+				key={`malformed-tool-${Date.now()}`}
+				message={errorContent}
+				hideBox={true}
+			/>,
+		);
+
+		// Create assistant message with the malformed content (so model knows what it said)
+		const assistantMsgWithError: Message = {
+			role: 'assistant',
+			content: fullContent,
+		};
+
+		// Create a user message with the error feedback for the model
+		const errorFeedbackMessage: Message = {
+			role: 'user',
+			content: `Your previous response contained a malformed tool call. ${errorContent}\n\nPlease try again using the correct format.`,
+		};
+
+		// Update messages and continue conversation loop for self-correction
+		const malformedBuilder = new MessageBuilder(messages);
+		malformedBuilder
+			.addAssistantMessage(assistantMsgWithError)
+			.addMessage(errorFeedbackMessage);
+		const updatedMessagesWithError = malformedBuilder.build();
+		setMessages(updatedMessagesWithError);
+
+		// Clear streaming state before recursing
+		setIsGenerating(false);
+		setStreamingContent('');
+
+		// Continue the main conversation loop with error message as context
+		await processAssistantResponse({
+			...params,
+			messages: updatedMessagesWithError,
+		});
+		return;
+	}
+
+	const parsedToolCalls = parseResult.toolCalls;
+	const cleanedContent = parseResult.cleanedContent;
+
+	// Display the assistant response (cleaned of any tool calls)
+	if (cleanedContent.trim()) {
+		addToChatQueue(
+			<AssistantMessage
+				key={`assistant-${componentKeyCounter}`}
+				message={cleanedContent}
+				model={currentModel}
+			/>,
+		);
+	}
+
+	// Merge structured tool calls from AI SDK with content-parsed tool calls
+	const allToolCalls = [...(toolCalls || []), ...parsedToolCalls];
+
+	const {validToolCalls, errorResults} = filterValidToolCalls(
+		allToolCalls,
+		toolManager,
+	);
+
+	// Add assistant message to conversation history only if it has content or tool_calls
+	// Empty assistant messages cause API errors: "Assistant message must have either content or tool_calls"
+	const assistantMsg: Message = {
+		role: 'assistant',
+		content: cleanedContent,
+		tool_calls: validToolCalls.length > 0 ? validToolCalls : undefined,
+	};
+
+	const hasValidAssistantMessage =
+		cleanedContent.trim() || validToolCalls.length > 0;
+
+	// Build updated messages array using MessageBuilder
+	const builder = new MessageBuilder(messages);
+
+	// Add auto-executed messages (assistant + tool results) from AI SDK multi-step execution
+	// This ensures they're counted in usage tracking and included in context
+	if (result.autoExecutedMessages && result.autoExecutedMessages.length > 0) {
+		builder.addAutoExecutedMessages(result.autoExecutedMessages);
+	}
+
+	// Add the final assistant message if it has content or tool calls
+	if (hasValidAssistantMessage) {
+		builder.addAssistantMessage(assistantMsg);
+
+		// Update conversation state with assistant message
+		conversationStateManager.current.updateAssistantMessage(assistantMsg);
+	}
+
+	// Build the final messages array
+	const updatedMessages = builder.build();
+
+	// Update messages state once with all changes
+	if (
+		(result.autoExecutedMessages && result.autoExecutedMessages.length > 0) ||
+		hasValidAssistantMessage
+	) {
+		setMessages(updatedMessages);
+	}
+
+	// Clear streaming state after response is complete
+	setIsGenerating(false);
+	setStreamingContent('');
+
+	// Handle error results for non-existent tools
+	if (errorResults.length > 0) {
+		// Display error messages to user
+		for (const error of errorResults) {
+			addToChatQueue(
+				<ErrorMessage
+					key={`unknown-tool-${error.tool_call_id}-${Date.now()}`}
+					message={error.content}
+					hideBox={true}
+				/>,
+			);
+		}
+
+		// Send error results back to model for self-correction
+		const errorBuilder = new MessageBuilder(updatedMessages);
+		errorBuilder.addToolResults(errorResults);
+		const updatedMessagesWithError = errorBuilder.build();
+		setMessages(updatedMessagesWithError);
+
+		// Continue the main conversation loop with error messages as context
+		await processAssistantResponse({
+			...params,
+			messages: updatedMessagesWithError,
+		});
+		return;
+	}
+
+	// Handle tool calls if present - this continues the loop
+	if (validToolCalls && validToolCalls.length > 0) {
+		// In Plan Mode, block file modification tools
+		if (developmentMode === 'plan') {
+			const fileModificationTools = [
+				'create_file',
+				'delete_lines',
+				'insert_lines',
+				'replace_lines',
+			];
+			const blockedTools = validToolCalls.filter(tc =>
+				fileModificationTools.includes(tc.function.name),
+			);
+
+			if (blockedTools.length > 0) {
+				// Create error results for blocked tools
+				const blockedToolErrors: ToolResult[] = blockedTools.map(toolCall => ({
+					tool_call_id: toolCall.id,
+					role: 'tool' as const,
+					name: toolCall.function.name,
+					content: `⚠ Tool "${toolCall.function.name}" is not allowed in Plan Mode. File modification tools are restricted in this mode. Switch to Normal Mode or Auto-accept Mode to execute file modifications.`,
+				}));
+
+				// Display error messages
+				for (const error of blockedToolErrors) {
+					addToChatQueue(
+						<ErrorMessage
+							key={`plan-mode-blocked-${error.tool_call_id}-${Date.now()}`}
+							message={error.content}
+							hideBox={true}
+						/>,
+					);
+				}
+
+				// Continue conversation with error messages
+				const blockedBuilder = new MessageBuilder(updatedMessages);
+				blockedBuilder.addToolResults(blockedToolErrors);
+				const updatedMessagesWithError = blockedBuilder.build();
+				setMessages(updatedMessagesWithError);
+
+				// Continue the main conversation loop with error messages as context
+				await processAssistantResponse({
+					...params,
+					messages: updatedMessagesWithError,
+				});
+				return;
+			}
+		}
+
+		// Separate tools that need confirmation vs those that don't
+		// Check tool's needsApproval property to determine if confirmation is needed
+		const toolsNeedingConfirmation: ToolCall[] = [];
+		const toolsToExecuteDirectly: ToolCall[] = [];
+
+		for (const toolCall of validToolCalls) {
+			// Check if tool has a validator
+			let validationFailed = false;
+
+			// XML validation errors are treated as validation failures
+			if (toolCall.function.name === '__xml_validation_error__') {
+				validationFailed = true;
+			} else if (toolManager) {
+				const validator = toolManager.getToolValidator(toolCall.function.name);
+				if (validator) {
+					try {
+						const parsedArgs = parseToolArguments(toolCall.function.arguments);
+
+						const validationResult = await validator(parsedArgs);
+						if (!validationResult.valid) {
+							validationFailed = true;
+						}
+					} catch {
+						// Validation threw an error - treat as validation failure
+						validationFailed = true;
+					}
+				}
+			}
+
+			// Check tool's needsApproval property from the tool definition
+			let toolNeedsApproval = true; // Default to requiring approval for safety
+			if (toolManager) {
+				const toolEntry = toolManager.getToolEntry(toolCall.function.name);
+				if (toolEntry?.tool) {
+					const needsApprovalProp = (
+						toolEntry.tool as unknown as {
+							needsApproval?:
+								| boolean
+								| ((args: unknown) => boolean | Promise<boolean>);
+						}
+					).needsApproval;
+					if (typeof needsApprovalProp === 'boolean') {
+						toolNeedsApproval = needsApprovalProp;
+					} else if (typeof needsApprovalProp === 'function') {
+						// Evaluate function - our tools use getCurrentMode() internally
+						// and don't actually need the args parameter
+						try {
+							const parsedArgs = parseToolArguments(
+								toolCall.function.arguments,
+							);
+							// Cast to any to handle AI SDK type signature mismatch
+							// Our tool implementations don't use the second parameter
+							toolNeedsApproval = await (
+								needsApprovalProp as (
+									args: unknown,
+								) => boolean | Promise<boolean>
+							)(parsedArgs);
+						} catch {
+							// If evaluation fails, require approval for safety
+							toolNeedsApproval = true;
+						}
+					}
+				}
+			}
+
+			// Execute directly if:
+			// 1. Validation failed (need to send error back to model)
+			// 2. Tool has needsApproval: false
+			// 3. In auto-accept mode (except bash which always needs approval)
+			const isBashTool = toolCall.function.name === 'execute_bash';
+			if (
+				validationFailed ||
+				!toolNeedsApproval ||
+				(developmentMode === 'auto-accept' && !isBashTool)
+			) {
+				toolsToExecuteDirectly.push(toolCall);
+			} else {
+				toolsNeedingConfirmation.push(toolCall);
+			}
+		}
+
+		// Execute non-confirmation tools directly
+		if (toolsToExecuteDirectly.length > 0) {
+			const directResults = await executeToolsDirectly(
+				toolsToExecuteDirectly,
+				toolManager,
+				conversationStateManager,
+				addToChatQueue,
+				componentKeyCounter,
+			);
+
+			// If we have results, continue the conversation with them
+			if (directResults.length > 0) {
+				// Add tool results to messages
+				const directBuilder = new MessageBuilder(updatedMessages);
+				directBuilder.addToolResults(directResults);
+				const updatedMessagesWithTools = directBuilder.build();
+				setMessages(updatedMessagesWithTools);
+
+				// Continue the main conversation loop with tool results as context
+				await processAssistantResponse({
+					...params,
+					messages: updatedMessagesWithTools,
+				});
+				return;
+			}
+		}
+
+		// Start confirmation flow only for tools that need it
+		if (toolsNeedingConfirmation.length > 0) {
+			// In non-interactive mode, exit when tool approval is required
+			if (nonInteractiveMode) {
+				const toolNames = toolsNeedingConfirmation
+					.map(tc => tc.function.name)
+					.join(', ');
+				const errorMsg = `Tool approval required for: ${toolNames}. Exiting non-interactive mode`;
+
+				// Add error message to UI
+				addToChatQueue(
+					<ErrorMessage
+						key={`tool-approval-required-${Date.now()}`}
+						message={errorMsg}
+						hideBox={true}
+					/>,
+				);
+
+				// Add error to messages array so exit detection can find it
+				const errorMessage: Message = {
+					role: 'assistant',
+					content: errorMsg,
+				};
+				// Use updatedMessages which already includes auto-executed tool results
+				const errorBuilder = new MessageBuilder(updatedMessages);
+				errorBuilder.addMessage(errorMessage);
+				setMessages(errorBuilder.build());
+
+				// Signal completion to trigger exit
+				if (onConversationComplete) {
+					onConversationComplete();
+				}
+				return;
+			}
+
+			// Pass complete messages including assistant msg
+			// useToolHandler will add tool results
+			onStartToolConfirmationFlow(
+				toolsNeedingConfirmation,
+				updatedMessages, // Includes assistant message
+				assistantMsg,
+				systemMessage,
+			);
+		}
+	}
+
+	// If no tool calls, the conversation naturally ends here
+	// BUT: if there's ALSO no content, that's likely an error - the model should have said something
+	// Auto-reprompt to help the model continue
+	if (validToolCalls.length === 0 && !cleanedContent.trim()) {
+		// Check if we just executed tools (updatedMessages should have tool results)
+		const lastMessage = updatedMessages[updatedMessages.length - 1];
+		const hasRecentToolResults = lastMessage?.role === 'tool';
+
+		// Add a continuation message to help the model respond
+		// For recent tool results, ask for a summary; otherwise, ask to continue
+		const nudgeContent = hasRecentToolResults
+			? 'Please provide a summary or response based on the tool results above.'
+			: 'Please continue with the task.';
+
+		const nudgeMessage: Message = {
+			role: 'user',
+			content: nudgeContent,
+		};
+
+		// Display a "continue" message in chat so user knows what happened
+		addToChatQueue(
+			<UserMessage
+				key={`auto-continue-${componentKeyCounter}`}
+				message="continue"
+			/>,
+		);
+
+		// Don't include the empty assistantMsg - it would cause API error
+		// "Assistant message must have either content or tool_calls"
+		const nudgeBuilder = new MessageBuilder(updatedMessages);
+		nudgeBuilder.addMessage(nudgeMessage);
+		const updatedMessagesWithNudge = nudgeBuilder.build();
+		setMessages(updatedMessagesWithNudge);
+
+		// Continue the conversation loop with the nudge
+		await processAssistantResponse({
+			...params,
+			messages: updatedMessagesWithNudge,
+		});
+		return;
+	}
+
+	if (validToolCalls.length === 0 && cleanedContent.trim()) {
+		onConversationComplete?.();
+	}
+};

package/source/hooks/chat-handler/conversation/tool-executor.spec.ts

@@ -0,0 +1,50 @@
+import test from 'ava';
+import {executeToolsDirectly} from './tool-executor.js';
+import type {ToolCall} from '@/types/core';
+
+// Note: This is a minimal smoke test since executeToolsDirectly has complex dependencies
+// Full integration testing would require extensive mocking of processToolUse, validators, etc.
+
+test('executeToolsDirectly - returns empty array for no tools', async t => {
+	const toolCalls: ToolCall[] = [];
+	const conversationStateManager = {
+		current: {
+			updateAfterToolExecution: () => {},
+		},
+	} as any;
+
+	const results = await executeToolsDirectly(
+		toolCalls,
+		null,
+		conversationStateManager,
+		() => {},
+		1,
+	);
+
+	t.deepEqual(results, []);
+});
+
+test('executeToolsDirectly - does not throw on execution', async t => {
+	const toolCalls: ToolCall[] = [
+		{
+			id: 'call_1',
+			function: {name: 'test_tool', arguments: {}},
+		},
+	];
+	const conversationStateManager = {
+		current: {
+			updateAfterToolExecution: () => {},
+		},
+	} as any;
+
+	// Should handle errors gracefully
+	await t.notThrowsAsync(async () => {
+		await executeToolsDirectly(
+			toolCalls,
+			null,
+			conversationStateManager,
+			() => {},
+			1,
+		);
+	});
+});

package/source/hooks/chat-handler/conversation/tool-executor.tsx

@@ -0,0 +1,109 @@
+import type {ConversationStateManager} from '@/app/utils/conversationState';
+import {ErrorMessage} from '@/components/message-box';
+import type {ToolManager} from '@/tools/tool-manager';
+import type {ToolCall, ToolResult} from '@/types/core';
+import {formatError} from '@/utils/error-formatter';
+import {parseToolArguments} from '@/utils/tool-args-parser';
+import {displayToolResult} from '@/utils/tool-result-display';
+import type React from 'react';
+
+/**
+ * Executes tools directly without confirmation.
+ * Handles validation, execution, and error display.
+ *
+ * @returns Array of tool results from executed tools
+ */
+export const executeToolsDirectly = async (
+	toolsToExecuteDirectly: ToolCall[],
+	toolManager: ToolManager | null,
+	conversationStateManager: React.MutableRefObject<ConversationStateManager>,
+	addToChatQueue: (component: React.ReactNode) => void,
+	componentKeyCounter: number,
+): Promise<ToolResult[]> => {
+	// Import processToolUse here to avoid circular dependencies
+	const {processToolUse} = await import('@/message-handler');
+	const directResults: ToolResult[] = [];
+
+	for (const toolCall of toolsToExecuteDirectly) {
+		try {
+			// Run validator if available
+			const validator = toolManager?.getToolValidator(toolCall.function.name);
+			if (validator) {
+				const parsedArgs = parseToolArguments(toolCall.function.arguments);
+
+				const validationResult = await validator(parsedArgs);
+				if (!validationResult.valid) {
+					// Validation failed - create error result and skip execution
+					const errorResult: ToolResult = {
+						tool_call_id: toolCall.id,
+						role: 'tool' as const,
+						name: toolCall.function.name,
+						content: validationResult.error,
+					};
+					directResults.push(errorResult);
+
+					// Update conversation state with error
+					conversationStateManager.current.updateAfterToolExecution(
+						toolCall,
+						errorResult.content,
+					);
+
+					// Display the validation error to the user
+					addToChatQueue(
+						<ErrorMessage
+							key={`validation-error-${toolCall.id}-${Date.now()}`}
+							message={validationResult.error}
+							hideBox={true}
+						/>,
+					);
+
+					continue; // Skip to next tool
+				}
+			}
+
+			const result = await processToolUse(toolCall);
+			directResults.push(result);
+
+			// Update conversation state with tool execution
+			conversationStateManager.current.updateAfterToolExecution(
+				toolCall,
+				result.content,
+			);
+
+			// Display the tool result immediately
+			await displayToolResult(
+				toolCall,
+				result,
+				toolManager,
+				addToChatQueue,
+				componentKeyCounter,
+			);
+		} catch (error) {
+			// Handle tool execution errors
+			const errorResult: ToolResult = {
+				tool_call_id: toolCall.id,
+				role: 'tool' as const,
+				name: toolCall.function.name,
+				content: `Error: ${formatError(error)}`,
+			};
+			directResults.push(errorResult);
+
+			// Update conversation state with error
+			conversationStateManager.current.updateAfterToolExecution(
+				toolCall,
+				errorResult.content,
+			);
+
+			// Display the error result
+			await displayToolResult(
+				toolCall,
+				errorResult,
+				toolManager,
+				addToChatQueue,
+				componentKeyCounter,
+			);
+		}
+	}
+
+	return directResults;
+};

package/source/hooks/chat-handler/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Chat handler module - manages LLM conversations and tool execution
+ *
+ * This module orchestrates the conversation flow between users and LLMs,
+ * handling streaming responses, tool calls, and conversation state.
+ */
+
+// Main hook
+export {useChatHandler} from './useChatHandler';
+
+// Types
+export type {UseChatHandlerProps, ChatHandlerReturn} from './types';

package/source/hooks/chat-handler/state/streaming-state.spec.ts

@@ -0,0 +1,26 @@
+import test from 'ava';
+import {createResetStreamingState} from './streaming-state.js';
+
+test('createResetStreamingState - resets all state', t => {
+	let isCancelling = true;
+	let abortController: AbortController | null = new AbortController();
+	let isGenerating = true;
+	let streamingContent = 'some content';
+	let tokenCount = 100;
+
+	const resetStreamingState = createResetStreamingState(
+		(val: boolean) => { isCancelling = val; },
+		(val: AbortController | null) => { abortController = val; },
+		(val: boolean) => { isGenerating = val; },
+		(val: string) => { streamingContent = val; },
+		(val: number) => { tokenCount = val; },
+	);
+
+	resetStreamingState();
+
+	t.is(isCancelling, false);
+	t.is(abortController as AbortController | null, null);
+	t.is(isGenerating, false);
+	t.is(streamingContent, '');
+	t.is(tokenCount, 0);
+});