Proper docs pass, v2 streams are now the default

Author: ericallam

docs/realtime/backend/input-streams.mdx

@@ -7,15 +7,15 @@ description: Send data into running tasks from your backend code
 The Input Streams API allows you to send data into running Trigger.dev tasks from your backend code. This enables bidirectional communication — while [output streams](/realtime/backend/streams) let you read data from tasks, input streams let you push data into them.
 
 <Note>
-  To learn how to receive input stream data inside your tasks, see our [Input
-  Streams](/tasks/input-streams) documentation.
+  To learn how to receive input stream data inside your tasks, see [Input
+  Streams](/tasks/streams#input-streams) in the Streams doc.
 </Note>
 
 ## Sending data to a running task
 
 ### Using defined input streams (Recommended)
 
-The recommended approach is to use [defined input streams](/tasks/input-streams#defining-input-streams) for full type safety:
+The recommended approach is to use [defined input streams](/tasks/streams#defining-input-streams) for full type safety:
 
 ```ts
 import { cancelSignal, approval } from "./trigger/streams";
@@ -32,7 +32,7 @@ The `.send()` method is fully typed — the data parameter must match the generi
 <Note>
   `.send()` works the same regardless of how the task is listening — whether it uses `.wait()`
   (suspending), `.once()` (non-suspending), or `.on()` (continuous). The sender doesn't need to know
-  how the task is consuming the data. See [Input Streams](/tasks/input-streams) for details on each
+  how the task is consuming the data. See [Input Streams](/tasks/streams#input-streams) for details on each
   receiving method.
 </Note>
 
@@ -152,4 +152,4 @@ try {
 - Maximum payload size per `.send()` call is **1MB**
 - You cannot send data to a completed, failed, or canceled run
 - Data sent before a listener is registered inside the task is **buffered** and delivered when a listener attaches
-- Input streams require [Realtime Streams v2](/tasks/streams#enabling-streams-v2) (enabled by default in SDK 4.1.0+)
+- Input streams require the current streams implementation (v2 is the default in SDK 4.1.0+). See [Streams](/tasks/streams) for details.

docs/realtime/react-hooks/streams.mdx

@@ -151,7 +151,70 @@ const { parts, error } = useRealtimeStream<string>(runId, {
 });
 ```
 
-For more information on defining and using streams, see the [Realtime Streams v2](/tasks/streams) documentation.
+For more information on defining and using streams, see the [Realtime Streams](/tasks/streams) documentation.
+
+## useInputStreamSend
+
+The `useInputStreamSend` hook lets you send data from your frontend into a running task's [input stream](/tasks/streams#input-streams). Use it for cancel buttons, approval forms, or any UI that needs to push typed data into a running task.
+
+### Basic usage
+
+Pass the input stream's `id` (string), the run ID, and options such as `accessToken`. You typically get `runId` and `accessToken` from the object returned when you trigger the task (e.g. `handle.id`, `handle.publicAccessToken`). The hook returns `send`, `isLoading`, `error`, and `isReady`:
+
+```tsx
+"use client";
+
+import { useInputStreamSend } from "@trigger.dev/react-hooks";
+import { approval } from "@/trigger/streams";
+
+export function ApprovalForm({
+  runId,
+  accessToken,
+}: {
+  runId: string;
+  accessToken: string;
+}) {
+  const { send, isLoading, isReady } = useInputStreamSend(
+    approval.id,
+    runId,
+    { accessToken }
+  );
+
+  return (
+    <button
+      disabled={!isReady || isLoading}
+      onClick={() => send({ approved: true, reviewer: "alice" })}
+    >
+      Approve
+    </button>
+  );
+}
+```
+
+With a generic for type-safe payloads when not using a defined stream:
+
+```tsx
+type ApprovalPayload = { approved: boolean; reviewer: string };
+const { send } = useInputStreamSend<ApprovalPayload>("approval", runId, {
+  accessToken,
+});
+send({ approved: true, reviewer: "alice" });
+```
+
+### Options and return value
+
+- **`streamId`**: The input stream identifier (string). Use the `id` from your defined stream (e.g. `approval.id`) or the same string you used in `streams.input<T>({ id: "approval" })`.
+- **`runId`**: The run to send input to. When `runId` is undefined, `isReady` is false and `send` will not trigger.
+- **`options`**: `accessToken` (required for client usage), `baseURL` (optional). See [Realtime auth](/realtime/auth) for generating a public access token with the right scopes (e.g. input streams write for that run).
+
+Return value:
+
+- **`send(data)`**: Sends typed data to the input stream. Uses SWR mutation under the hood.
+- **`isLoading`**: True while a send is in progress.
+- **`error`**: Set if the last send failed.
+- **`isReady`**: True when both `runId` and access token are available.
+
+For receiving input stream data inside a task (`.wait()`, `.once()`, `.on()`), see [Input Streams](/tasks/streams#input-streams) in the Streams doc.
 
 ## useRealtimeRunWithStreams