diff --git a/refact-agent/engine/src/tools/tools_execute.rs b/refact-agent/engine/src/tools/tools_execute.rs
index 5f78fee30..bb45f147a 100644
--- a/refact-agent/engine/src/tools/tools_execute.rs
+++ b/refact-agent/engine/src/tools/tools_execute.rs
@@ -203,7 +203,7 @@ pub async fn run_tools(
                         let command_to_match = cmd
                             .command_to_match_against_confirm_deny(&args)
                             .unwrap_or("<error_command>".to_string());
-                        generated_tool.push(tool_answer(format!("tool use: command '{command_to_match}' has been denied by the user"), t_call.id.to_string()));
+                        generated_tool.push(tool_answer(format!("Whoops the user didn't like the command '{command_to_match}'. Stop and ask for correction from the user."), t_call.id.to_string()));
                         continue;
                     }
                     _ => {}
diff --git a/refact-agent/gui/src/app/middleware.ts b/refact-agent/gui/src/app/middleware.ts
index ee4efbaa1..2a416322d 100644
--- a/refact-agent/gui/src/app/middleware.ts
+++ b/refact-agent/gui/src/app/middleware.ts
@@ -12,6 +12,9 @@ import {
   newIntegrationChat,
   chatResponse,
   setThreadUsage,
+  setIsWaitingForResponse,
+  upsertToolCall,
+  sendCurrentChatToLspAfterToolCallUpdate,
 } from "../features/Chat/Thread";
 import { statisticsApi } from "../services/refact/statistics";
 import { integrationsApi } from "../services/refact/integrations";
@@ -32,12 +35,17 @@ import { resetAttachedImagesSlice } from "../features/AttachedImages";
 import { nextTip } from "../features/TipOfTheDay";
 import { telemetryApi } from "../services/refact/telemetry";
 import { CONFIG_PATH_URL, FULL_PATH_URL } from "../services/refact/consts";
-import { resetConfirmationInteractedState } from "../features/ToolConfirmation/confirmationSlice";
+import {
+  resetConfirmationInteractedState,
+  updateConfirmationAfterIdeToolUse,
+} from "../features/ToolConfirmation/confirmationSlice";
 import {
   updateAgentUsage,
   updateMaxAgentUsageAmount,
 } from "../features/AgentUsage/agentUsageSlice";
 import { isChatResponseChoice } from "../services/refact";
+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";
@@ -501,3 +509,33 @@ startListening({
     }
   },
 });
+
+// Tool Call results from ide.
+startListening({
+  actionCreator: ideToolCallResponse,
+  effect: (action, listenerApi) => {
+    const state = listenerApi.getState();
+
+    listenerApi.dispatch(upsertToolCallIntoHistory(action.payload));
+    listenerApi.dispatch(upsertToolCall(action.payload));
+    listenerApi.dispatch(updateConfirmationAfterIdeToolUse(action.payload));
+
+    const pauseReasons = state.confirmation.pauseReasons.filter(
+      (reason) => reason.tool_call_id !== action.payload.toolCallId,
+    );
+
+    if (pauseReasons.length === 0) {
+      listenerApi.dispatch(resetConfirmationInteractedState());
+      listenerApi.dispatch(setIsWaitingForResponse(false));
+    }
+
+    if (pauseReasons.length === 0 && action.payload.accepted) {
+      void listenerApi.dispatch(
+        sendCurrentChatToLspAfterToolCallUpdate({
+          chatId: action.payload.chatId,
+          toolCallId: action.payload.toolCallId,
+        }),
+      );
+    }
+  },
+});
diff --git a/refact-agent/gui/src/components/ChatContent/ChatContent.tsx b/refact-agent/gui/src/components/ChatContent/ChatContent.tsx
index 3030a8d22..3f1d80ce9 100644
--- a/refact-agent/gui/src/components/ChatContent/ChatContent.tsx
+++ b/refact-agent/gui/src/components/ChatContent/ChatContent.tsx
@@ -34,6 +34,7 @@ import { ChatLinks, UncommittedChangesWarning } from "../ChatLinks";
 import { telemetryApi } from "../../services/refact/telemetry";
 import { PlaceHolderText } from "./PlaceHolderText";
 import { UsageCounter } from "../UsageCounter";
+import { getConfirmationPauseStatus } from "../../features/ToolConfirmation/confirmationSlice";
 
 export type ChatContentProps = {
   onRetry: (index: number, question: UserMessage["content"]) => void;
@@ -55,6 +56,7 @@ export const ChatContent: React.FC<ChatContentProps> = ({
   const [sendTelemetryEvent] =
     telemetryApi.useLazySendTelemetryChatEventQuery();
   const integrationMeta = useAppSelector(selectIntegration);
+  const isWaitingForConfirmation = useAppSelector(getConfirmationPauseStatus);
 
   const {
     handleScroll,
@@ -119,7 +121,7 @@ export const ChatContent: React.FC<ChatContentProps> = ({
         {threadUsage && <UsageCounter usage={threadUsage} />}
 
         <Container py="4">
-          <Spinner spinning={isWaiting} />
+          <Spinner spinning={isWaiting && !isWaitingForConfirmation} />
         </Container>
       </Flex>
       {showFollowButton && (
diff --git a/refact-agent/gui/src/components/ChatForm/ToolConfirmation.tsx b/refact-agent/gui/src/components/ChatForm/ToolConfirmation.tsx
index ece33dfd2..1295ec711 100644
--- a/refact-agent/gui/src/components/ChatForm/ToolConfirmation.tsx
+++ b/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,9 +171,9 @@ export const ToolConfirmation: React.FC<ToolConfirmationProps> = ({
               color="red"
               variant="surface"
               size="1"
-              onClick={rejectToolUsage}
+              onClick={handleReject}
             >
-              Deny
+              Stop
             </Button>
           )}
         </Flex>
@@ -258,7 +262,7 @@ const PatchConfirmation: React.FC<PatchConfirmationProps> = ({
             size="1"
             onClick={rejectToolUsage}
           >
-            Deny
+            Stop
           </Button>
         </Flex>
       </Flex>
diff --git a/refact-agent/gui/src/components/Tools/Texdoc.module.css b/refact-agent/gui/src/components/Tools/Texdoc.module.css
index fb6fabb2d..344b8188d 100644
--- a/refact-agent/gui/src/components/Tools/Texdoc.module.css
+++ b/refact-agent/gui/src/components/Tools/Texdoc.module.css
@@ -18,15 +18,9 @@
   margin-top: 0;
 }
 
-:global(.radix-themes) .textdoc.textdoc__update :global(.hljs.language-diff) {
+/* :global(.radix-themes) .textdoc.textdoc__update :global(.hljs.language-diff) {
   --hlbg: var(--gray-3);
   --hlcolor1: var(--gray-12);
-  /* --hlcolor2: #000000;
-  --hlcolor3: #000080;
-  --hlcolor4: #800080;
-  --hlcolor5: #808000;
-  --hlcolor6: #800000;
-  --hlcolor7: #0055af; */
   --hlcolor8: var(--green-9);
   --hlcolor9: var(--red-9);
 }
@@ -44,4 +38,4 @@
 
 .textdoc__update .textdoc__diffbox {
   box-shadow: var(--shadow-1);
-}
+} */
diff --git a/refact-agent/gui/src/components/Tools/Textdoc.tsx b/refact-agent/gui/src/components/Tools/Textdoc.tsx
index 17b63209a..dfafe949e 100644
--- a/refact-agent/gui/src/components/Tools/Textdoc.tsx
+++ b/refact-agent/gui/src/components/Tools/Textdoc.tsx
@@ -12,17 +12,17 @@ import {
   isUpdateTextDocToolCall,
   parseRawTextDocToolCall,
 } from "./types";
-import { Box, Button, Card, Flex } from "@radix-ui/themes";
+import { Box, Card, Flex, Button } from "@radix-ui/themes";
 import { TruncateLeft } from "../Text";
 import { Link } from "../Link";
 import { useEventsBusForIDE } from "../../hooks/useEventBusForIDE";
 import { Markdown } from "../Markdown";
 import { filename } from "../../utils/filename";
 import styles from "./Texdoc.module.css";
-import { createPatch } from "diff";
-import classNames from "classnames";
+import { useCopyToClipboard } from "../../hooks/useCopyToClipboard";
+import { Reveal } from "../Reveal";
 import { useAppSelector } from "../../hooks";
-import { selectCanPaste } from "../../features/Chat";
+import { selectCanPaste, selectChatId } from "../../features/Chat";
 import { toolsApi } from "../../services/refact";
 import { ErrorCallout } from "../Callout";
 import { isRTKResponseErrorWithDetailMessage } from "../../utils";
@@ -56,12 +56,14 @@ export const TextDocTool: React.FC<{ toolCall: RawTextDocTool }> = ({
 const TextDocHeader: React.FC<{
   toolCall: TextDocToolCall;
 }> = ({ toolCall }) => {
-  const { openFile, diffPasteBack, sendToolEditToIde } = useEventsBusForIDE();
+  const { openFile, diffPasteBack, sendToolCallToIde } = useEventsBusForIDE();
   const [requestDryRun, dryRunResult] = toolsApi.useDryRunForEditToolMutation();
   const [errorMessage, setErrorMessage] = useState<string>("");
   const canPaste = useAppSelector(selectCanPaste);
+  const chatId = useAppSelector(selectChatId);
 
   const clearErrorMessage = useCallback(() => setErrorMessage(""), []);
+
   // move this
   const handleOpenFile = useCallback(() => {
     if (!toolCall.function.arguments.path) return;
@@ -70,9 +72,9 @@ const TextDocHeader: React.FC<{
 
   const handleReplace = useCallback(
     (content: string) => {
-      diffPasteBack(content);
+      diffPasteBack(content, chatId, toolCall.id);
     },
-    [diffPasteBack],
+    [chatId, diffPasteBack, toolCall.id],
   );
 
   const replaceContent = useMemo(() => {
@@ -90,7 +92,7 @@ const TextDocHeader: React.FC<{
     })
       .then((results) => {
         if (results.data) {
-          sendToolEditToIde(toolCall.function.arguments.path, results.data);
+          sendToolCallToIde(toolCall, results.data, chatId);
         } else if (isRTKResponseErrorWithDetailMessage(results)) {
           setErrorMessage(results.error.data.detail);
         }
@@ -107,12 +109,7 @@ const TextDocHeader: React.FC<{
           setErrorMessage("Error with patch: " + JSON.stringify(error));
         }
       });
-  }, [
-    requestDryRun,
-    sendToolEditToIde,
-    toolCall.function.arguments,
-    toolCall.function.name,
-  ]);
+  }, [chatId, requestDryRun, sendToolCallToIde, toolCall]);
 
   return (
     <Card size="1" variant="surface" mt="4" className={styles.textdoc__header}>
@@ -140,6 +137,7 @@ const TextDocHeader: React.FC<{
         {replaceContent && (
           <Button
             size="1"
+            // this one can directly dismiss the tool confirmation.
             onClick={() => handleReplace(replaceContent)}
             disabled={dryRunResult.isLoading || !canPaste}
             title="Replace the current selection in the ide."
@@ -166,11 +164,17 @@ const CreateTextDoc: React.FC<{
       "```" + extension + "\n" + toolCall.function.arguments.content + "\n```"
     );
   }, [toolCall.function.arguments.content, toolCall.function.arguments.path]);
+  const handleCopy = useCopyToClipboard();
+
+  const lineCount = useMemo(() => code.split("\n").length, [code]);
+
   return (
     // TODO: move this box up a bit, or make it generic
     <Box className={styles.textdoc}>
       <TextDocHeader toolCall={toolCall} />
-      <Markdown>{code}</Markdown>
+      <Reveal isRevealingCode defaultOpen={lineCount < 9}>
+        <Markdown onCopyClick={handleCopy}>{code}</Markdown>
+      </Reveal>
     </Box>
   );
 };
@@ -191,11 +195,20 @@ const ReplaceTextDoc: React.FC<{
     toolCall.function.arguments.path,
     toolCall.function.arguments.replacement,
   ]);
+
+  const copyToClipBoard = useCopyToClipboard();
+  const handleCopy = useCallback(() => {
+    copyToClipBoard(toolCall.function.arguments.replacement);
+  }, [copyToClipBoard, toolCall.function.arguments.replacement]);
+
+  const lineCount = useMemo(() => code.split("\n").length, [code]);
   return (
     // TODO: move this box up a bit, or make it generic
     <Box className={styles.textdoc}>
       <TextDocHeader toolCall={toolCall} />
-      <Markdown>{code}</Markdown>
+      <Reveal isRevealingCode defaultOpen={lineCount < 9}>
+        <Markdown onCopyClick={handleCopy}>{code}</Markdown>
+      </Reveal>
     </Box>
   );
 };
@@ -219,10 +232,14 @@ const UpdateRegexTextDoc: React.FC<{
     toolCall.function.arguments.replacement,
   ]);
 
+  const lineCount = useMemo(() => code.split("\n").length, [code]);
+
   return (
     <Box className={styles.textdoc}>
       <TextDocHeader toolCall={toolCall} />
-      <Markdown>{code}</Markdown>
+      <Reveal isRevealingCode defaultOpen={lineCount < 9}>
+        <Markdown>{code}</Markdown>
+      </Reveal>
     </Box>
   );
 };
@@ -230,26 +247,33 @@ const UpdateRegexTextDoc: React.FC<{
 const UpdateTextDoc: React.FC<{
   toolCall: UpdateTextDocToolCall;
 }> = ({ toolCall }) => {
-  const diff = useMemo(() => {
-    const patch = createPatch(
-      toolCall.function.arguments.path,
-      toolCall.function.arguments.old_str,
-      toolCall.function.arguments.replacement,
+  const code = useMemo(() => {
+    const extension = getFileExtension(toolCall.function.arguments.path);
+    return (
+      "```" +
+      extension +
+      "\n" +
+      toolCall.function.arguments.replacement +
+      "\n```"
     );
-
-    return "```diff\n" + patch + "\n```";
   }, [
-    toolCall.function.arguments.replacement,
-    toolCall.function.arguments.old_str,
     toolCall.function.arguments.path,
+    toolCall.function.arguments.replacement,
   ]);
-  // TODO: don't use markdown for this, it's two bright
+
+  const lineCount = useMemo(() => code.split("\n").length, [code]);
+
+  const copyToClipBoard = useCopyToClipboard();
+  const handleCopy = useCallback(() => {
+    copyToClipBoard(toolCall.function.arguments.replacement);
+  }, [copyToClipBoard, toolCall.function.arguments.replacement]);
+
   return (
-    <Box className={classNames(styles.textdoc, styles.textdoc__update)}>
+    <Box className={styles.textdoc}>
       <TextDocHeader toolCall={toolCall} />
-      <Box className={classNames(styles.textdoc__diffbox)}>
-        <Markdown useInlineStyles={false}>{diff}</Markdown>
-      </Box>
+      <Reveal isRevealingCode defaultOpen={lineCount < 9}>
+        <Markdown onCopyClick={handleCopy}>{code}</Markdown>
+      </Reveal>
     </Box>
   );
 };
diff --git a/refact-agent/gui/src/contexts/AbortControllers.tsx b/refact-agent/gui/src/contexts/AbortControllers.tsx
index 67c3260f7..57d2f723a 100644
--- a/refact-agent/gui/src/contexts/AbortControllers.tsx
+++ b/refact-agent/gui/src/contexts/AbortControllers.tsx
@@ -35,7 +35,7 @@ export const AbortControllerProvider: React.FC<{
   const abort = (key: string, reason?: string) => {
     if (key in abortControllers) {
       const fn = abortControllers[key];
-      fn(reason);
+      fn(reason ?? "aborted");
       removeController(key);
     }
   };
diff --git a/refact-agent/gui/src/events/index.ts b/refact-agent/gui/src/events/index.ts
index 0f3de6e46..dc897daa9 100644
--- a/refact-agent/gui/src/events/index.ts
+++ b/refact-agent/gui/src/events/index.ts
@@ -32,6 +32,7 @@ export {
   setCurrentProjectInfo,
   type CurrentProjectInfo,
 } from "../features/Chat/currentProject";
+export type { TextDocToolCall } from "../components/Tools/types";
 
 export type {
   ToolCommand,
@@ -73,7 +74,8 @@ export {
   ideEscapeKeyPressed,
   ideIsChatStreaming,
   ideIsChatReady,
-  ideToolEdit,
+  ideToolCall,
+  ideToolCallResponse,
 } from "../hooks/useEventBusForIDE";
 
 export const fim = {
diff --git a/refact-agent/gui/src/features/Chat/Thread/actions.ts b/refact-agent/gui/src/features/Chat/Thread/actions.ts
index 7ebe6d106..cc1d51776 100644
--- a/refact-agent/gui/src/features/Chat/Thread/actions.ts
+++ b/refact-agent/gui/src/features/Chat/Thread/actions.ts
@@ -19,6 +19,7 @@ import {
   // isChatGetTitleResponse,
   isToolCallMessage,
   isToolMessage,
+  isUserMessage,
   ToolCall,
   ToolMessage,
   type ChatMessages,
@@ -32,10 +33,11 @@ import {
   generateChatTitle,
   sendChat,
 } from "../../../services/refact/chat";
-import { ToolCommand } from "../../../services/refact/tools";
+import { ToolCommand, toolsApi } 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");
 
@@ -155,6 +157,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;
@@ -372,3 +378,58 @@ export const chatAskQuestionThunk = createAppAsyncThunk<
       });
   },
 );
+
+export const sendCurrentChatToLspAfterToolCallUpdate = createAppAsyncThunk<
+  unknown,
+  { chatId: string; toolCallId: string }
+>(
+  "chatThread/sendCurrentChatToLspAfterToolCallUpdate",
+  async ({ chatId, toolCallId }, thunkApi) => {
+    const state = thunkApi.getState();
+    const toolUse = state.chat.thread.tool_use;
+    if (state.chat.thread.id !== chatId) return;
+    if (
+      state.chat.streaming ||
+      state.chat.prevent_send ||
+      state.chat.waiting_for_response
+    ) {
+      return;
+    }
+    const lastMessages = takeFromEndWhile(
+      state.chat.thread.messages,
+      (message) => !isUserMessage(message) && !isAssistantMessage(message),
+    );
+
+    const toolUseInThisSet = lastMessages.some(
+      (message) =>
+        isToolMessage(message) && message.content.tool_call_id === toolCallId,
+    );
+
+    if (!toolUseInThisSet) return;
+    thunkApi.dispatch(setIsWaitingForResponse(true));
+    // duplicate in sendChat
+    let tools = await thunkApi
+      .dispatch(toolsApi.endpoints.getTools.initiate(undefined))
+      .unwrap();
+
+    if (toolUse === "quick") {
+      tools = [];
+    } else if (toolUse === "explore") {
+      tools = tools.filter((t) => !t.function.agentic);
+    }
+    tools = tools.map((t) => {
+      const { agentic: _, ...remaining } = t.function;
+      return { ...t, function: { ...remaining } };
+    });
+
+    return thunkApi.dispatch(
+      chatAskQuestionThunk({
+        messages: state.chat.thread.messages,
+        tools,
+        chatId,
+        mode: state.chat.thread.mode,
+        checkpointsEnabled: state.chat.checkpoints_enabled,
+      }),
+    );
+  },
+);
diff --git a/refact-agent/gui/src/features/Chat/Thread/reducer.ts b/refact-agent/gui/src/features/Chat/Thread/reducer.ts
index a898ad008..fe5f8aab1 100644
--- a/refact-agent/gui/src/features/Chat/Thread/reducer.ts
+++ b/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,
@@ -36,11 +36,19 @@ import {
   setIsNewChatSuggested,
   setIsNewChatSuggestionRejected,
   setThreadUsage,
+  upsertToolCall,
 } from "./actions";
 import { formatChatResponse } from "./utils";
 import {
+  ChatMessages,
   DEFAULT_MAX_NEW_TOKENS,
+  isAssistantMessage,
+  isDiffMessage,
+  isMultiModalToolResult,
   isToolCallMessage,
+  isToolMessage,
+  ToolCall,
+  ToolMessage,
   validateToolCall,
 } from "../../../services/refact";
 import { calculateUsageInputTokens } from "../../../utils/calculateUsageInputTokens";
@@ -363,4 +371,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.";
+}
diff --git a/refact-agent/gui/src/features/History/historySlice.ts b/refact-agent/gui/src/features/History/historySlice.ts
index b0974084a..5ef3f1b00 100644
--- a/refact-agent/gui/src/features/History/historySlice.ts
+++ b/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;
 
diff --git a/refact-agent/gui/src/features/ToolConfirmation/confirmationSlice.ts b/refact-agent/gui/src/features/ToolConfirmation/confirmationSlice.ts
index 344522c0d..129c62585 100644
--- a/refact-agent/gui/src/features/ToolConfirmation/confirmationSlice.ts
+++ b/refact-agent/gui/src/features/ToolConfirmation/confirmationSlice.ts
@@ -1,5 +1,6 @@
 import { createSlice, PayloadAction } from "@reduxjs/toolkit";
 import type { ToolConfirmationPauseReason } from "../../services/refact";
+import { ideToolCallResponse } from "../../hooks/useEventBusForIDE";
 
 export type ConfirmationState = {
   pauseReasons: ToolConfirmationPauseReason[];
@@ -48,6 +49,19 @@ export const confirmationSlice = createSlice({
       state.pauseReasons = [];
       state.status = action.payload;
     },
+
+    updateConfirmationAfterIdeToolUse(
+      state,
+      action: PayloadAction<Parameters<typeof ideToolCallResponse>[0]>,
+    ) {
+      const pauseReasons = state.pauseReasons.filter(
+        (reason) => reason.tool_call_id !== action.payload.toolCallId,
+      );
+      if (pauseReasons.length === 0) {
+        state.status.wasInteracted = true; // work around for auto send.
+      }
+      state.pauseReasons = pauseReasons;
+    },
   },
   selectors: {
     getPauseReasonsWithPauseStatus: (state) => state,
@@ -61,6 +75,7 @@ export const {
   setPauseReasons,
   resetConfirmationInteractedState,
   clearPauseReasonsAndHandleToolsStatus,
+  updateConfirmationAfterIdeToolUse,
 } = confirmationSlice.actions;
 export const {
   getPauseReasonsWithPauseStatus,
diff --git a/refact-agent/gui/src/hooks/index.ts b/refact-agent/gui/src/hooks/index.ts
index 4d5932835..02dc1b971 100644
--- a/refact-agent/gui/src/hooks/index.ts
+++ b/refact-agent/gui/src/hooks/index.ts
@@ -28,3 +28,4 @@ export * from "./useAgentUsage";
 export * from "./useOpenUrl";
 export * from "./useCapsForToolUse";
 export * from "./useCanUseTools";
+export * from "./useCopyToClipboard";
diff --git a/refact-agent/gui/src/hooks/useCopyToClipboard.ts b/refact-agent/gui/src/hooks/useCopyToClipboard.ts
new file mode 100644
index 000000000..d8481acef
--- /dev/null
+++ b/refact-agent/gui/src/hooks/useCopyToClipboard.ts
@@ -0,0 +1,45 @@
+import { useCallback } from "react";
+import { telemetryApi } from "../services/refact";
+import { fallbackCopying } from "../utils/fallbackCopying";
+
+export const useCopyToClipboard = () => {
+  const [sendTelemetryEvent] =
+    telemetryApi.useLazySendTelemetryChatEventQuery();
+
+  const handleCopy = useCallback(
+    (text: string) => {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (window.navigator?.clipboard?.writeText) {
+        void window.navigator.clipboard
+          .writeText(text)
+          .catch(() => {
+            // eslint-disable-next-line no-console
+            console.log("failed to copy to clipboard");
+            void sendTelemetryEvent({
+              scope: `codeBlockCopyToClipboard`,
+              success: false,
+              error_message:
+                "window.navigator?.clipboard?.writeText: failed to copy to clipboard",
+            });
+          })
+          .then(() => {
+            void sendTelemetryEvent({
+              scope: `codeBlockCopyToClipboard`,
+              success: true,
+              error_message: "",
+            });
+          });
+      } else {
+        fallbackCopying(text);
+        void sendTelemetryEvent({
+          scope: `codeBlockCopyToClipboard`,
+          success: true,
+          error_message: "",
+        });
+      }
+    },
+    [sendTelemetryEvent],
+  );
+
+  return handleCopy;
+};
diff --git a/refact-agent/gui/src/hooks/useEventBusForApp.ts b/refact-agent/gui/src/hooks/useEventBusForApp.ts
index e0c19b5b6..51738a162 100644
--- a/refact-agent/gui/src/hooks/useEventBusForApp.ts
+++ b/refact-agent/gui/src/hooks/useEventBusForApp.ts
@@ -12,6 +12,7 @@ import {
   push,
   selectPages,
 } from "../features/Pages/pagesSlice";
+import { ideToolCallResponse } from "./useEventBusForIDE";
 
 export function useEventBusForApp() {
   const config = useConfig();
@@ -43,6 +44,12 @@ export function useEventBusForApp() {
         dispatch(setCurrentProjectInfo(event.data.payload));
       }
 
+      if (ideToolCallResponse.match(event.data)) {
+        dispatch(event.data);
+      }
+
+      // TODO: ideToolEditResponse.
+
       // TODO: active project
       // vscode workspace can be found with vscode.workspace.name
       // JB: project.name
diff --git a/refact-agent/gui/src/hooks/useEventBusForIDE.ts b/refact-agent/gui/src/hooks/useEventBusForIDE.ts
index c6cc54c33..32dcd1286 100644
--- a/refact-agent/gui/src/hooks/useEventBusForIDE.ts
+++ b/refact-agent/gui/src/hooks/useEventBusForIDE.ts
@@ -7,8 +7,17 @@ import {
   HostSettings,
   SetupHost,
 } from "../events/setup";
+import { pathApi } from "../services/refact/path";
 
-export const ideDiffPasteBackAction = createAction<string>("ide/diffPasteBack");
+import { telemetryApi } from "../services/refact/telemetry";
+import { ToolEditResult } from "../services/refact";
+import { TextDocToolCall } from "../components/Tools/types";
+
+export const ideDiffPasteBackAction = createAction<{
+  content: string;
+  chatId?: string;
+  toolCallId?: string;
+}>("ide/diffPasteBack");
 
 export const ideOpenSettingsAction = createAction("ide/openSettings");
 
@@ -38,14 +47,17 @@ export const ideEscapeKeyPressed = createAction<string>("ide/escapeKeyPressed");
 export const ideIsChatStreaming = createAction<boolean>("ide/isChatStreaming");
 export const ideIsChatReady = createAction<boolean>("ide/isChatReady");
 
-export const ideToolEdit = createAction<{ path: string; edit: ToolEditResult }>(
-  "ide/toolEdit",
-);
-
-import { pathApi } from "../services/refact/path";
+export const ideToolCall = createAction<{
+  toolCall: TextDocToolCall;
+  chatId: string;
+  edit: ToolEditResult;
+}>("ide/toolEdit");
 
-import { telemetryApi } from "../services/refact/telemetry";
-import { ToolEditResult } from "../services/refact";
+export const ideToolCallResponse = createAction<{
+  toolCallId: string;
+  chatId: string;
+  accepted: boolean | "indeterminate";
+}>("ide/toolEditResponse");
 
 export const useEventsBusForIDE = () => {
   const [sendTelemetryEvent] =
@@ -84,8 +96,8 @@ export const useEventsBusForIDE = () => {
   );
 
   const diffPasteBack = useCallback(
-    (content: string) => {
-      const action = ideDiffPasteBackAction(content);
+    (content: string, chatId?: string, toolCallId?: string) => {
+      const action = ideDiffPasteBackAction({ content, chatId, toolCallId });
       postMessage(action);
       void sendTelemetryEvent({
         scope: `replaceSelection`,
@@ -217,9 +229,9 @@ export const useEventsBusForIDE = () => {
   const openBringYourOwnKeyFile = () =>
     openFileFromPathQuery(getBringYourOwnKeyPath);
 
-  const sendToolEditToIde = useCallback(
-    (path: string, edit: ToolEditResult) => {
-      const action = ideToolEdit({ path, edit });
+  const sendToolCallToIde = useCallback(
+    (toolCall: TextDocToolCall, edit: ToolEditResult, chatId: string) => {
+      const action = ideToolCall({ toolCall, edit, chatId });
       postMessage(action);
     },
     [postMessage],
@@ -244,6 +256,6 @@ export const useEventsBusForIDE = () => {
     escapeKeyPressed,
     setIsChatStreaming,
     setIsChatReady,
-    sendToolEditToIde,
+    sendToolCallToIde,
   };
 };
diff --git a/refact-agent/gui/src/hooks/useSendChatRequest.ts b/refact-agent/gui/src/hooks/useSendChatRequest.ts
index 75ab938d5..28ef04031 100644
--- a/refact-agent/gui/src/hooks/useSendChatRequest.ts
+++ b/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 =
   | {
@@ -319,16 +321,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"]) => {
@@ -376,6 +389,7 @@ export function useAutoSend() {
       !preventSend
     ) {
       const lastMessage = currentMessages.slice(-1)[0];
+      // here ish
       if (
         isAssistantMessage(lastMessage) &&
         lastMessage.tool_calls &&
diff --git a/refact-agent/gui/src/services/refact/types.ts b/refact-agent/gui/src/services/refact/types.ts
index b4127d3a1..4fccecb10 100644
--- a/refact-agent/gui/src/services/refact/types.ts
+++ b/refact-agent/gui/src/services/refact/types.ts
@@ -80,12 +80,12 @@ export interface MultiModalToolResult extends BaseToolResult {
 
 export type ToolResult = SingleModelToolResult | MultiModalToolResult;
 
-type MultiModalToolContent = {
+export type MultiModalToolContent = {
   m_type: string; // "image/*" | "text" ... maybe narrow this?
   m_content: string; // base64 if image,
 };
 
-function isMultiModalToolContent(
+export function isMultiModalToolContent(
   content: unknown,
 ): content is MultiModalToolContent {
   if (!content) return false;