fix(patch): continue if accepted or allow clicked, stop if rejected of stop clicked.

Author: MarcMcIntosh

refact-agent/gui/src/app/middleware.ts

@@ -12,6 +12,7 @@ import {
   newIntegrationChat,
   chatResponse,
   setIsWaitingForResponse,
+  upsertToolCall,
 } from "../features/Chat/Thread";
 import { statisticsApi } from "../services/refact/statistics";
 import { integrationsApi } from "../services/refact/integrations";
@@ -46,6 +47,7 @@ import {
   updateMaxAgentUsageAmount,
 } from "../features/AgentUsage/agentUsageSlice";
 import { ideToolCallResponse } from "../hooks/useEventBusForIDE";
+import { upsertToolCallIntoHistory } from "../features/History/historySlice";
 
 const AUTH_ERROR_MESSAGE =
   "There is an issue with your API key. Check out your API Key or re-login";
@@ -509,6 +511,11 @@ startListening({
   effect: (action, listenerApi) => {
     const state = listenerApi.getState();
 
+    if (action.payload.accepted === false) {
+      listenerApi.dispatch(upsertToolCallIntoHistory(action.payload));
+      listenerApi.dispatch(upsertToolCall(action.payload));
+    }
+
     listenerApi.dispatch(updateConfirmationAfterIdeToolUse(action.payload));
 
     const pauseReasons = state.confirmation.pauseReasons.filter(

refact-agent/gui/src/components/ChatForm/ToolConfirmation.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo } from "react";
+import React, { useCallback, useMemo } from "react";
 import {
   PATCH_LIKE_FUNCTIONS,
   useAppDispatch,
@@ -88,6 +88,10 @@ export const ToolConfirmation: React.FC<ToolConfirmationProps> = ({
     confirmToolUsage();
   };
 
+  const handleReject = useCallback(() => {
+    rejectToolUsage(toolCallIds);
+  }, [rejectToolUsage, toolCallIds]);
+
   const message = getConfirmationMessage(
     commands,
     rules,
@@ -101,7 +105,7 @@ export const ToolConfirmation: React.FC<ToolConfirmationProps> = ({
     return (
       <PatchConfirmation
         handleAllowForThisChat={handleAllowForThisChat}
-        rejectToolUsage={rejectToolUsage}
+        rejectToolUsage={handleReject}
         confirmToolUsage={confirmToolUsage}
       />
     );
@@ -167,7 +171,7 @@ export const ToolConfirmation: React.FC<ToolConfirmationProps> = ({
               color="red"
               variant="surface"
               size="1"
-              onClick={rejectToolUsage}
+              onClick={handleReject}
             >
               Stop
             </Button>

refact-agent/gui/src/features/Chat/Thread/actions.ts

@@ -34,6 +34,7 @@ import { ToolCommand } from "../../../services/refact/tools";
 import { scanFoDuplicatesWith, takeFromEndWhile } from "../../../utils";
 import { debugApp } from "../../../debugConfig";
 import { ChatHistoryItem } from "../../History/historySlice";
+import { ideToolCallResponse } from "../../../hooks/useEventBusForIDE";
 
 export const newChatAction = createAction("chatThread/new");
 
@@ -144,6 +145,10 @@ export const fixBrokenToolMessages = createAction<PayloadWithId>(
   "chatThread/fixBrokenToolMessages",
 );
 
+export const upsertToolCall = createAction<
+  Parameters<typeof ideToolCallResponse>[0] & { replaceOnly?: boolean }
+>("chatThread/upsertToolCall");
+
 // TODO: This is the circular dep when imported from hooks :/
 const createAppAsyncThunk = createAsyncThunk.withTypes<{
   state: RootState;

refact-agent/gui/src/features/Chat/Thread/reducer.ts

@@ -1,4 +1,4 @@
-import { createReducer } from "@reduxjs/toolkit";
+import { createReducer, Draft } from "@reduxjs/toolkit";
 import {
   Chat,
   ChatThread,
@@ -35,11 +35,19 @@ import {
   fixBrokenToolMessages,
   setIsNewChatSuggested,
   setIsNewChatSuggestionRejected,
+  upsertToolCall,
 } from "./actions";
 import { formatChatResponse } from "./utils";
 import {
+  ChatMessages,
   DEFAULT_MAX_NEW_TOKENS,
+  isAssistantMessage,
+  isDiffMessage,
+  isMultiModalToolResult,
   isToolCallMessage,
+  isToolMessage,
+  ToolCall,
+  ToolMessage,
   validateToolCall,
 } from "../../../services/refact";
 
@@ -334,4 +342,100 @@ export const chatReducer = createReducer(initialState, (builder) => {
     const newMessage = { ...lastMessage, tool_calls: validToolCalls };
     state.thread.messages = [...messages, newMessage];
   });
+
+  builder.addCase(upsertToolCall, (state, action) => {
+    // if (action.payload.toolCallId !== state.thread.id && !(action.payload.chatId in state.cache)) return state;
+    if (action.payload.chatId === state.thread.id) {
+      maybeAppendToolCallResultFromIdeToMessages(
+        state.thread.messages,
+        action.payload.toolCallId,
+        action.payload.accepted,
+      );
+    } else if (action.payload.chatId in state.cache) {
+      const thread = state.cache[action.payload.chatId];
+      maybeAppendToolCallResultFromIdeToMessages(
+        thread.messages,
+        action.payload.toolCallId,
+        action.payload.accepted,
+        action.payload.replaceOnly,
+      );
+    }
+  });
 });
+
+export function maybeAppendToolCallResultFromIdeToMessages(
+  messages: Draft<ChatMessages>,
+  toolCallId: string,
+  accepted: boolean | "indeterminate",
+  replaceOnly = false,
+) {
+  const hasDiff = messages.find(
+    (d) => isDiffMessage(d) && d.tool_call_id === toolCallId,
+  );
+  if (hasDiff) return;
+
+  const maybeToolResult = messages.find(
+    (d) => isToolMessage(d) && d.content.tool_call_id === toolCallId,
+  );
+
+  const toolCalls = messages.reduce<ToolCall[]>((acc, message) => {
+    if (!isAssistantMessage(message)) return acc;
+    if (!message.tool_calls) return acc;
+    return acc.concat(message.tool_calls);
+  }, []);
+
+  const maybeToolCall = toolCalls.find(
+    (toolCall) => toolCall.id === toolCallId,
+  );
+
+  const message = messageForToolCall(accepted, maybeToolCall);
+
+  if (replaceOnly && !maybeToolResult) return;
+
+  if (
+    maybeToolResult &&
+    isToolMessage(maybeToolResult) &&
+    typeof maybeToolResult.content.content === "string"
+  ) {
+    maybeToolResult.content.content = message;
+    return;
+  } else if (
+    maybeToolResult &&
+    isToolMessage(maybeToolResult) &&
+    isMultiModalToolResult(maybeToolResult.content)
+  ) {
+    maybeToolResult.content.content.push({
+      m_type: "text",
+      m_content: message,
+    });
+    return;
+  }
+
+  const assistantMessageIndex = messages.findIndex((message) => {
+    if (!isAssistantMessage(message)) return false;
+    return message.tool_calls?.find((toolCall) => toolCall.id === toolCallId);
+  });
+
+  if (assistantMessageIndex === -1) return;
+  const toolMessage: ToolMessage = {
+    role: "tool",
+    content: {
+      content: message,
+      tool_call_id: toolCallId,
+    },
+  };
+
+  messages.splice(assistantMessageIndex + 1, 0, toolMessage);
+}
+
+function messageForToolCall(
+  accepted: boolean | "indeterminate",
+  toolCall?: ToolCall,
+) {
+  if (accepted === false && toolCall?.function.name) {
+    `Whoops the user didn't like the command ${toolCall.function.name}. Stop and ask for correction from the user.`;
+  }
+  if (accepted === false) return "The user rejected the changes.";
+  if (accepted === true) return "The user accepted the changes.";
+  return "The user may have made modifications to changes.";
+}

refact-agent/gui/src/features/History/historySlice.ts

@@ -9,6 +9,7 @@ import {
   chatGenerateTitleThunk,
   ChatThread,
   doneStreaming,
+  maybeAppendToolCallResultFromIdeToMessages,
   removeChatFromCache,
   restoreChat,
   setChatMode,
@@ -20,6 +21,7 @@ import {
   isUserMessage,
 } from "../../services/refact";
 import { AppDispatch, RootState } from "../../app/store";
+import { ideToolCallResponse } from "../../hooks/useEventBusForIDE";
 
 export type ChatHistoryItem = Omit<ChatThread, "new_chat_suggested"> & {
   createdAt: string;
@@ -143,6 +145,23 @@ export const historySlice = createSlice({
     clearHistory: () => {
       return {};
     },
+
+    upsertToolCallIntoHistory: (
+      state,
+      action: PayloadAction<
+        Parameters<typeof ideToolCallResponse>[0] & {
+          replaceOnly?: boolean;
+        }
+      >,
+    ) => {
+      if (!(action.payload.chatId in state)) return;
+      maybeAppendToolCallResultFromIdeToMessages(
+        state[action.payload.chatId].messages,
+        action.payload.toolCallId,
+        action.payload.accepted,
+        action.payload.replaceOnly,
+      );
+    },
   },
   selectors: {
     getChatById: (state, id: string): ChatHistoryItem | null => {
@@ -165,6 +184,7 @@ export const {
   setTitleGenerationCompletionForChat,
   updateChatTitleById,
   clearHistory,
+  upsertToolCallIntoHistory,
 } = historySlice.actions;
 export const { getChatById, getHistory } = historySlice.selectors;
 

refact-agent/gui/src/hooks/useEventBusForIDE.ts

@@ -55,6 +55,7 @@ export const ideToolCall = createAction<{
 
 export const ideToolCallResponse = createAction<{
   toolCallId: string;
+  chatId: string;
   accepted: boolean | "indeterminate";
 }>("ide/toolEditResponse");
 

refact-agent/gui/src/hooks/useSendChatRequest.ts

@@ -50,9 +50,11 @@ import {
   setChatMode,
   setIsWaitingForResponse,
   setLastUserMessageId,
+  upsertToolCall,
 } from "../features/Chat";
 
 import { v4 as uuidv4 } from "uuid";
+import { upsertToolCallIntoHistory } from "../features/History/historySlice";
 
 type SubmitHandlerParams =
   | {
@@ -318,16 +320,27 @@ export const useSendChatRequest = () => {
     dispatch(setIsWaitingForResponse(false));
   }, [abort, dispatch]);
 
-  const rejectToolUsage = useCallback(() => {
-    abort();
-    dispatch(
-      clearPauseReasonsAndHandleToolsStatus({
-        wasInteracted: true,
-        confirmationStatus: false,
-      }),
-    );
-    dispatch(setIsWaitingForResponse(false));
-  }, [abort, dispatch]);
+  const rejectToolUsage = useCallback(
+    (toolCallIds: string[]) => {
+      abort();
+
+      toolCallIds.forEach((toolCallId) => {
+        dispatch(
+          upsertToolCallIntoHistory({ toolCallId, chatId, accepted: false }),
+        );
+        dispatch(upsertToolCall({ toolCallId, chatId, accepted: false }));
+      });
+
+      dispatch(
+        clearPauseReasonsAndHandleToolsStatus({
+          wasInteracted: true,
+          confirmationStatus: false,
+        }),
+      );
+      dispatch(setIsWaitingForResponse(false));
+    },
+    [abort, chatId, dispatch],
+  );
 
   const retryFromIndex = useCallback(
     (index: number, question: UserMessage["content"]) => {