@@ -0,0 +1,13 @@
+---
+"@trigger.dev/sdk": minor
+---
+
+Actions are sent through `useChat` so a turn that follows one renders like any turn. `TriggerChatTransport` recognises `body.action` on a `useChat` request and sends it as an action, so `sendMessage(undefined, { body: { action } })` or `regenerate({ body: { action } })` sends the action and `useChat` owns the response: it streams into the message list, `status` and `error` behave as for a message, and `stop` works. `useChatActions({ sendMessage })` in `@trigger.dev/sdk/chat/react` is a two-line convenience over that.
+
+```tsx
+const { sendMessage } = useChat({ id: chatId, transport });
+const { sendAction } = useChatActions({ sendMessage });
+sendAction({ type: "regenerate" });
+```
+
+Previously the frontend docs said `useChat` consumed the stream `transport.sendAction` returns; it never did, so an action's answer was never rendered by an app following them. `transport.sendAction` is unchanged for callers outside `useChat` and still returns a stream the caller must read.
@@ -442,45 +442,48 @@ function Chat({ chatId, transport }) {
 
 ## Sending actions
 
-Send custom actions (undo, rollback, edit) to the agent via `transport.sendAction()`. Actions wake the agent and fire only `hydrateMessages` (if configured) and `onAction` — they're not turns, so `onTurnStart` / `prepareMessages` / `onBeforeTurnComplete` / `onTurnComplete` and `run()` do not fire.
-
-For optimistic UI, mirror the action's effect on the `useChat` state via `setMessages` while the request is in flight:
+Send custom actions (undo, rollback, edit, regenerate) as `useChat` requests, with the action in the request `body`. The transport recognises `body.action` and sends it as an action rather than a message, and because `useChat` made the request it owns the response: an action that returns `chat.turn()` on the server streams its answer into the message list like any turn, with `status`, `error` and `stop` behaving as for a message. An action that returns nothing completes with no message added.
 
 ```tsx
+import { useChat } from "@ai-sdk/react";
+import { useChatActions, useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
+
 function ChatControls({ chatId }: { chatId: string }) {
   const transport = useTriggerChatTransport({
     task: "my-chat",
     accessToken: ({ chatId }) => mintChatAccessToken(chatId),
-    startSession: ({ chatId, clientData }) =>
-      startChatSession({ chatId, clientData }),
+    startSession: ({ chatId, clientData }) => startChatSession({ chatId, clientData }),
   });
-
-  const { setMessages } = useChat({ transport });
+  const { sendMessage, regenerate, setMessages } = useChat({ id: chatId, transport });
+  const { sendAction } = useChatActions({ sendMessage });
 
   return (
     <div>
       <button
         onClick={() => {
-          void transport.sendAction(chatId, { type: "undo" });
+          // Mirror the server-side edit optimistically; the server does not
+          // push history changes back.
           setMessages((prev) => prev.slice(0, -2));
+          void sendAction({ type: "undo" });
         }}
       >
         Undo last exchange
       </button>
-      <button
-        onClick={() => transport.sendAction(chatId, { type: "rollback", targetMessageId: "msg-5" })}
-      >
-        Rollback to message
+      {/* regenerate() removes the trailing answer locally; the server does the same before its turn */}
+      <button onClick={() => regenerate({ body: { action: { type: "regenerate" } } })}>
+        Regenerate
       </button>
     </div>
   );
 }
 ```
 
-The action payload is validated against the agent's `actionSchema` on the backend — invalid actions are rejected. See [Actions](/ai-chat/actions) for the backend setup.
+`useChatActions` is a two-line convenience over `sendMessage(undefined, { body: { action } })`. Any `useChat` request can carry an action the same way, `regenerate({ body })` included.
+
+The action payload is validated against the agent's `actionSchema` on the backend; invalid actions are rejected. See [Actions](/ai-chat/actions) for the backend setup.
 
 <Note>
-  `sendAction` returns a `ReadableStream<UIMessageChunk>`. For side-effect-only actions (where `onAction` returns `void`), the stream completes immediately with `trigger:turn-complete`. For actions where `onAction` returns a `StreamTextResult`, the stream carries the assistant chunks the same way `sendMessages` does — `useChat` consumes them automatically.
+  `transport.sendAction()` still exists for callers outside `useChat` (server to server, or a custom client). It returns the response as a raw `ReadableStream<UIMessageChunk>` that the caller must read; `useChat` does not consume it.
 </Note>
 
 For server-to-server usage, `AgentChat` has the same method:
 
@@ -471,3 +471,46 @@ export function usePendingMessages<TUIMessage extends UIMessage = UIMessage>(
     getInjectedMessages,
   };
 }
+
+/**
+ * Send actions through `useChat`, so an action that returns `chat.turn()` on
+ * the server renders like any turn.
+ *
+ * `transport.sendAction` returns the response as a stream that `useChat` never
+ * reads. This hook sends the action as a `useChat` request instead (the
+ * transport recognises `body.action` and sends it as an action), so `useChat`
+ * owns the response: it streams into the message list, `status` and `error`
+ * behave as for a message, and `stop` works. An action that returns nothing on
+ * the server completes with no message added.
+ *
+ * History changes the action makes on the server (an undo removing messages,
+ * for example) are not mirrored automatically; apply those with `setMessages`
+ * optimistically, as before.
+ *
+ * @example
+ * ```tsx
+ * const transport = useTriggerChatTransport({ task: "my-chat", accessToken });
+ * const { messages, sendMessage, setMessages } = useChat({ id: chatId, transport });
+ * const { sendAction } = useChatActions({ sendMessage });
+ *
+ * <button onClick={() => sendAction({ type: "regenerate" })}>Regenerate</button>
+ * ```
+ */
+export function useChatActions(options: {
+  /** `useChat`'s `sendMessage`. */
+  sendMessage: (
+    message: undefined,
+    options?: { body?: object; headers?: Record<string, string> | Headers }
+  ) => Promise<void> | void;
+}): {
+  /** Send an action; resolves when `useChat` has finished the request. */
+  sendAction: (action: unknown) => Promise<void>;
+} {
+  const { sendMessage } = options;
+  const sendMessageRef = useRef(sendMessage);
+  sendMessageRef.current = sendMessage;
+  const sendAction = useCallback(async (action: unknown) => {
+    await sendMessageRef.current(undefined, { body: { action } });
+  }, []);
+  return { sendAction };
+}
@@ -982,6 +982,42 @@ describe("TriggerChatTransport", () => {
       expect(actionBody.payload.action).toEqual({ type: "undo" });
     });
 
+    it("sends a useChat request carrying body.action as an action", async () => {
+      // `useChatActions` and `regenerate({ body })` reach the transport through
+      // `sendMessages`; the action has to go out as an action, not a message,
+      // and the response comes back on the request useChat made.
+      let actionBody: any;
+      global.fetch = vi.fn().mockImplementation(async (url: string | URL, init?: RequestInit) => {
+        const urlStr = typeof url === "string" ? url : url.toString();
+        if (isSessionStreamAppendUrl(urlStr)) {
+          actionBody = JSON.parse(init!.body as string);
+          return defaultAppendResponse();
+        }
+        if (isSessionOutSubscribeUrl(urlStr)) return defaultSseResponse();
+        throw new Error(`Unexpected URL: ${urlStr}`);
+      });
+
+      const transport = new TriggerChatTransport({
+        task: "my-chat-task",
+        accessToken: () => "pat",
+        sessions: { "chat-act-body": { publicAccessToken: "p" } },
+      });
+
+      const stream = await transport.sendMessages({
+        trigger: "submit-message",
+        chatId: "chat-act-body",
+        messageId: undefined,
+        messages: [{ id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] }],
+        abortSignal: undefined,
+        body: { action: { type: "regenerate" } },
+      });
+      await drainChunks(stream);
+
+      expect(actionBody.payload.trigger).toBe("action");
+      expect(actionBody.payload.action).toEqual({ type: "regenerate" });
+      expect(actionBody.payload.message).toBeUndefined();
+    });
+
     it("marks the session streaming and notifies before subscribing", async () => {
       global.fetch = vi.fn().mockImplementation(async (url: string | URL) => {
         const urlStr = typeof url === "string" ? url : url.toString();
 
@@ -802,6 +802,15 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
         ? { ...(this.defaultMetadata ?? {}), ...((metadata as Record<string, unknown>) ?? {}) }
         : undefined;
 
+    // An action sent through `useChat`. `useChatActions` (or any caller) puts
+    // it in `body.action`; sending it here rather than through
+    // `transport.sendAction` means `useChat` owns the response stream, so an
+    // action that becomes a turn renders the way a message turn does.
+    const actionInBody = (body as { action?: unknown } | undefined)?.action;
+    if (actionInBody !== undefined) {
+      return this.sendAction(chatId, actionInBody, { abortSignal });
+    }
+
     // First-turn handover routing — when `headStart` is set AND no
     // session state exists yet for this chatId, POST the wire payload
     // to the customer's `chat.handover` route handler. The handler
@@ -1257,7 +1266,11 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
    * `StreamTextResult`); for `void`-returning side-effect-only actions
    * the stream completes immediately with `trigger:turn-complete`.
    */
-  sendAction = async (chatId: string, action: unknown): Promise<ReadableStream<UIMessageChunk>> => {
+  sendAction = async (
+    chatId: string,
+    action: unknown,
+    options?: { abortSignal?: AbortSignal }
+  ): Promise<ReadableStream<UIMessageChunk>> => {
     if (this.coordinator) {
       if (this.coordinator.isReadOnly(chatId)) {
         throw new Error("This chat is active in another tab");
@@ -1306,7 +1319,7 @@ export class TriggerChatTransport implements ChatTransport<UIMessage> {
     this.notifySessionChange(chatId, state);
 
     // Owning action: aborting this send stops the turn the user drives.
-    return this.subscribeToSessionStream(state, undefined, chatId, {
+    return this.subscribeToSessionStream(state, options?.abortSignal, chatId, {
       sinceInSeq: inSeq,
       sendStopOnAbort: true,
     });