@gguf/coder 0.3.1 → 0.3.2

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

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

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

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

@@ -1,12 +0,0 @@
-/**
- * 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

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