Eric Allam
540e1c86a4
Input streams enable sending typed data to executing tasks from external
callers — backends, frontends, or other tasks. This unlocks interactive
use cases like approval UIs, cancel buttons, chat interfaces, and
human-in-the-loop AI workflows where the task needs to receive data
while running.
Three consumption patterns inside a task:
* `.wait()` — Suspend the task until data arrives (process freed, most
efficient)
* `.once()` — Wait for the next message (process stays alive)
* `.on()` — Subscribe to a continuous stream of messages
One send pattern from outside:
* `.send(runId, data)` — Send typed data to a specific run's input
stream
## User-facing API
### Define a typed input stream
```ts
import { streams, task } from "@trigger.dev/sdk";
const approval = streams.input<{ approved: boolean; reviewer: string }>({ id: "approval" });
```
### Consume inside a task
```ts
export const myTask = task({
id: "my-task",
run: async () => {
// Pattern 1: Suspend until data arrives (most efficient — frees the process)
const result = await approval.wait({ timeout: "5m" });
// Pattern 2: Wait for next message (process stays alive)
const data = await approval.once().unwrap();
// Pattern 3: Subscribe to multiple messages
approval.on((data) => { /* handle each message */ });
},
});
```
### Send from outside
```ts
// From a backend (using secret API key)
await approval.send(runId, { approved: true, reviewer: "alice" });
// From a frontend (using public JWT token from trigger response)
const { send } = useInputStreamSend("approval", runId, { accessToken });
send({ approved: true, reviewer: "alice" });
```
---------
Co-authored-by: Claude <noreply@anthropic.com>
101 lines
2.4 KiB
TypeScript
101 lines
2.4 KiB
TypeScript
import { Redis } from "ioredis";
|
|
import { env } from "~/env.server";
|
|
import { singleton } from "~/utils/singleton";
|
|
import { logger } from "./logger.server";
|
|
|
|
const KEY_PREFIX = "isw:";
|
|
const DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
|
|
|
|
function buildKey(runFriendlyId: string, streamId: string): string {
|
|
return `${KEY_PREFIX}${runFriendlyId}:${streamId}`;
|
|
}
|
|
|
|
function initializeRedis(): Redis | undefined {
|
|
const host = env.CACHE_REDIS_HOST;
|
|
if (!host) {
|
|
return undefined;
|
|
}
|
|
|
|
return new Redis({
|
|
connectionName: "inputStreamWaitpointCache",
|
|
host,
|
|
port: env.CACHE_REDIS_PORT,
|
|
username: env.CACHE_REDIS_USERNAME,
|
|
password: env.CACHE_REDIS_PASSWORD,
|
|
keyPrefix: "tr:",
|
|
enableAutoPipelining: true,
|
|
...(env.CACHE_REDIS_TLS_DISABLED === "true" ? {} : { tls: {} }),
|
|
});
|
|
}
|
|
|
|
const redis = singleton("inputStreamWaitpointCache", initializeRedis);
|
|
|
|
/**
|
|
* Store a mapping from input stream to waitpoint ID in Redis.
|
|
* Called when `.wait()` creates a new waitpoint.
|
|
*/
|
|
export async function setInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string,
|
|
waitpointId: string,
|
|
ttlMs?: number
|
|
): Promise<void> {
|
|
if (!redis) return;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
await redis.set(key, waitpointId, "PX", ttlMs ?? DEFAULT_TTL_MS);
|
|
} catch (error) {
|
|
logger.error("Failed to set input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the waitpoint ID for an input stream without deleting it.
|
|
* Called from the `.send()` route before completing the waitpoint.
|
|
*/
|
|
export async function getInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string
|
|
): Promise<string | null> {
|
|
if (!redis) return null;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
return await redis.get(key);
|
|
} catch (error) {
|
|
logger.error("Failed to get input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Delete the cache entry for an input stream waitpoint.
|
|
* Called when a waitpoint is completed or timed out.
|
|
*/
|
|
export async function deleteInputStreamWaitpoint(
|
|
runFriendlyId: string,
|
|
streamId: string
|
|
): Promise<void> {
|
|
if (!redis) return;
|
|
|
|
try {
|
|
const key = buildKey(runFriendlyId, streamId);
|
|
await redis.del(key);
|
|
} catch (error) {
|
|
logger.error("Failed to delete input stream waitpoint cache", {
|
|
runFriendlyId,
|
|
streamId,
|
|
error,
|
|
});
|
|
}
|
|
}
|