docs: add input streams documentation to realtime guides

Cover the problems input streams solve (cancelling AI SDK streamText
mid-stream, human-in-the-loop workflows, interactive agents), the full
API surface (on, once, peek, send), and a complete cancellable AI
streaming example.

Updates rules/4.3.0/realtime.md, manifest.json, and the Claude Code
skill docs.

https://claude.ai/code/session_01SJHJts7r2yAxmoKLLz8vpc

Author: claude

.claude/skills/trigger-dev-tasks/realtime.md

@@ -9,6 +9,7 @@ Realtime allows you to:
 - Subscribe to run status changes, metadata updates, and streams
 - Build real-time dashboards and UI updates
 - Monitor task progress from frontend and backend
+- Send data into running tasks with input streams
 
 ## Authentication
 
@@ -103,6 +104,143 @@ for await (const chunk of stream) {
 }
 ```
 
+## Input Streams
+
+Input streams let you send data **into** a running task from your backend or frontend. Output streams send data out of tasks; input streams complete the loop.
+
+### Problems Input Streams Solve
+
+**Cancelling AI streams mid-generation.** When you use AI SDK's `streamText` inside a task, the LLM keeps generating tokens until it's done — even if the user has navigated away or clicked "Stop generating." Without input streams, there's no way to tell the running task to abort. With input streams, your frontend sends a cancel signal and the task aborts the LLM call immediately.
+
+**Human-in-the-loop workflows.** A task generates a draft, then pauses and waits for user approval before proceeding.
+
+**Interactive agents.** An AI agent running as a task needs follow-up information from the user mid-execution.
+
+### Defining Input Streams
+
+```ts
+// trigger/streams.ts
+import { streams } from "@trigger.dev/sdk";
+
+export const cancelSignal = streams.input<{ reason?: string }>({ id: "cancel" });
+export const approval = streams.input<{ approved: boolean; reviewer: string }>({ id: "approval" });
+```
+
+### Receiving Data Inside a Task
+
+#### `once()` — Wait for the next value
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { approval } from "./streams";
+
+export const draftEmailTask = task({
+  id: "draft-email",
+  run: async (payload: { to: string; subject: string }) => {
+    const draft = await generateDraft(payload);
+    const result = await approval.once(); // Blocks until data arrives
+
+    if (result.approved) {
+      await sendEmail(draft);
+    }
+    return { sent: result.approved, reviewer: result.reviewer };
+  },
+});
+```
+
+Options: `once({ timeoutMs: 300_000 })` or `once({ signal: controller.signal })`.
+
+#### `on()` — Listen for every value
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { cancelSignal } from "./streams";
+
+export const streamingTask = task({
+  id: "streaming-task",
+  run: async (payload: { prompt: string }) => {
+    const controller = new AbortController();
+
+    const sub = cancelSignal.on(() => {
+      controller.abort();
+    });
+
+    try {
+      const result = await streamText({
+        model: openai("gpt-4o"),
+        prompt: payload.prompt,
+        abortSignal: controller.signal,
+      });
+      return result;
+    } finally {
+      sub.off();
+    }
+  },
+});
+```
+
+#### `peek()` — Non-blocking check
+
+```ts
+const latest = cancelSignal.peek(); // undefined if nothing received yet
+```
+
+### Sending Data to a Running Task
+
+```ts
+import { cancelSignal, approval } from "./trigger/streams";
+
+await cancelSignal.send(runId, { reason: "User clicked stop" });
+await approval.send(runId, { approved: true, reviewer: "alice@example.com" });
+```
+
+### Full Example: Cancellable AI Streaming
+
+```ts
+// trigger/streams.ts
+import { streams } from "@trigger.dev/sdk";
+
+export const aiOutput = streams.define<string>({ id: "ai" });
+export const cancelStream = streams.input<{ reason?: string }>({ id: "cancel" });
+```
+
+```ts
+// trigger/ai-task.ts
+import { task } from "@trigger.dev/sdk";
+import { streamText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { aiOutput, cancelStream } from "./streams";
+
+export const aiTask = task({
+  id: "ai-chat",
+  run: async (payload: { prompt: string }) => {
+    const controller = new AbortController();
+    const sub = cancelStream.on(() => controller.abort());
+
+    try {
+      const result = streamText({
+        model: openai("gpt-4o"),
+        prompt: payload.prompt,
+        abortSignal: controller.signal,
+      });
+
+      const { waitUntilComplete } = aiOutput.pipe(result.textStream);
+      await waitUntilComplete();
+      return { text: await result.text };
+    } finally {
+      sub.off();
+    }
+  },
+});
+```
+
+### Important Notes
+
+- Input streams require v2 realtime streams (SDK 4.1.0+). Calling `.on()` or `.once()` without v2 throws an error.
+- Cannot send data to completed/failed/canceled runs.
+- Max 1MB per `.send()` call.
+- Data sent before a listener is registered gets buffered and delivered when a listener attaches.
+
 ## React Frontend Usage
 
 ### Installation
@@ -242,3 +380,5 @@ Key properties available in run subscriptions:
 - **Handle errors**: Always check for errors in hooks and subscriptions
 - **Type safety**: Use task types for proper payload/output typing
 - **Cleanup subscriptions**: Backend subscriptions auto-complete, frontend hooks auto-cleanup
+- **Clean up input stream listeners**: Always call `.off()` in a `finally` block to avoid leaks
+- **Use timeouts with `once()`**: Avoid hanging indefinitely if the signal never arrives