Channels

Every option for the Telegram, Slack and WhatsApp channels in @intentface/latch-channels.

What channels are for: Channels. What they handle for you: Chat apps.

Each platform is a subpath, and each channel has one handleRequest(request) for its webhook route.

import { telegramChannel } from "@intentface/latch-channels/telegram";

Option	Type	Default
`agent`	`string`	—
The agent this bot answers as, by name. `string`
`botRef`	`string`	—
Your own id for this bot, for example its row id in your database. Chat ids are built from it (`telegram_<botRef>_<userId>`), so changing the bot's token or account later keeps every conversation. `string`
`botToken`	`TelegramToken`	—
The bot's token from BotFather, or a function that reads it, for example from the vault. `TelegramToken`
`webhookSecret`	`string \| (() => string \| Promise<string>)`	—
The secret you registered with Telegram's `setWebhook`; requests without it are refused. `string \| (() => string \| Promise<string>)`
`runtime`	`ChannelRunOps<P>`	—
Your runtime. `ChannelRunOps<P>`
`authorizeUser`	`(user: TelegramUser) => Promise<AuthResult<P>>`	—
Who this Telegram user is in your app. Return `{ allowed: true, principal }`, or `{ allowed: false, linkUrl }` to send them a link to connect their account; their message is held (`stashPending`) and answered once they have. Runs on every message, so removing someone in your app stops the bot for them. `(user: TelegramUser) => Promise<AuthResult<P>>`
`seen?`	`((deliveryKey: string) => Promise<boolean>)`	—
Returns `true` if this delivery was seen before, and records it if not. Telegram resends until it gets a quick reply; back this with a table with an expiry so a resend is ignored on any server. `((deliveryKey: string) => Promise<boolean>) \| undefined`
`claimTurn?`	`((chatId: string) => Promise<string \| null>)`	—
Only for a storage adapter that doesn't refuse a second answer per chat itself; the built-in ones do. `((chatId: string) => Promise<string \| null>) \| undefined`
`releaseTurn?`	`((chatId: string, token: string) => Promise<void>)`	—
`((chatId: string, token: string) => Promise<void>) \| undefined`
`stashPending?`	`function`	—
Keeps the message from a user who still has to connect their account, to answer after they do. `((input: TelegramUser & { text: string; media?: InboundMedia<TgFileRef>[]; }) => Promise<void>) \| undefined`
`authorizeUrl?`	`function`	—
The URL that starts signing in to a service when the agent asks the user to connect it. `((connectionName: string, ctx: { chatId: string; telegramUserId: string; approvalId: string; }) => string) \| undefined`
`transcribe?`	`TranscribeAudio`	—
Turns voice notes into text. Without it, the user is asked to type instead. `TranscribeAudio \| undefined`
`askState?`	`AskStateStore`	—
Keeps the state of a question the agent asked with buttons, between taps. `AskStateStore \| undefined`
`thread?`	`ChannelThreadStore`	—
Remembers the user's current conversation, so `/new` can start a fresh one. `ChannelThreadStore \| undefined`
`waitUntil?`	`((p: Promise<unknown>) => void)`	—
Keeps a serverless function running after the quick reply to Telegram, for example Vercel's `waitUntil`. `((p: Promise<unknown>) => void) \| undefined`
`apiOptions?`	`TelegramApiOptions`	—
For tests: a different Bot API URL or `fetch`. `TelegramApiOptions \| undefined`

Slack

import { slackChannel } from "@intentface/latch-channels/slack";

Option	Type	Default
`agent`	`string`	—
The agent this Slack app answers as, by name. Each agent has its own Slack app. `string`
`appId`	`string`	—
The Slack app's id. Chat ids are built from it, so two apps never share a conversation. `string`
`principal`	`P`	—
Who the bot acts as, unless `authorizeUser` returns a principal for the person asking. `P`
`botToken`	`SlackToken`	—
The workspace's bot token, or a function that reads it, for example from the vault. `SlackToken`
`runtime`	`ChannelRunOps<P>`	—
Your runtime. `ChannelRunOps<P>`
`botUserId`	`string`	—
The bot's own Slack user id, from installing the app. The bot ignores its own messages by this id, so it never answers itself. `string`
`teamId`	`string`	—
The workspace the app is installed in. Needed to stream answers in channels. `string`
`signingSecret`	`string \| (() => string \| Promise<string>)`	—
The app's signing secret; requests not signed with it are refused. `string \| (() => string \| Promise<string>)`
`waitUntil?`	`((p: Promise<unknown>) => void)`	—
Keeps a serverless function running after the quick reply to Slack, for example Vercel's `waitUntil`. Without it the reply waits for the whole answer, which is fine on a long-running server but makes Slack retry on serverless. `((p: Promise<unknown>) => void) \| undefined`
`claimOnce`	`(key: string, ttlMs: number) => Promise<boolean>`	—
Claims a key for a while: returns `true` for the first call, `false` while it's held. Back it with a table with an expiry. It's how Slack's retries, one message arriving as two events, and repeated button presses are handled once, on any server. `(key: string, ttlMs: number) => Promise<boolean>`
`claimTurn?`	`((chatId: string) => Promise<string \| null>)`	—
Only for a storage adapter that doesn't refuse a second answer per chat itself; the built-in ones do. `((chatId: string) => Promise<string \| null>) \| undefined`
`releaseTurn?`	`((chatId: string, token: string) => Promise<void>)`	—
`((chatId: string, token: string) => Promise<void>) \| undefined`
`threads`	`SlackThreadStore`	—
Remembers who started each thread, and whether the bot was told to stop in it. `SlackThreadStore`
`authorizeUser?`	`function`	—
Decides whether this Slack user may use the bot, and as whom. Return `{ allowed: true, principal }` to answer as that person (with their own connected accounts), `{ allowed: false, linkUrl }` to ask them to connect their account, or add `silent: true` to refuse without replying. `((user: { teamId: string; userId: string; channelId: string; threadRoot: string; anchorTs?: string; prompt: string; }) => Promise<AuthResult<P>>) \| undefined`
`authorizeUrl?`	`function`	—
The URL that starts signing in to a service when the agent asks the user to connect it. `((connectionName: string, ctx: { chatId: string; channelId: string; threadTs: string; userId: string; approvalId: string; }) => string) \| undefined`
`onLifecycle?`	`function`	—
Called when the app is uninstalled or its tokens are revoked, so you can turn the bot off. `((info: { type: "tokens_revoked" \| "app_uninstalled"; teamId: string; }) => Promise<void>) \| undefined`
`onStreamMode?`	`function`	—
Called when Latch decides whether to stream an answer or post it when done, with Slack's reason when streaming was refused. Save it to show why a bot stopped streaming. `((info: { chatId: string; mode: "stream" \| "fallback"; code?: string; detail?: string; }) => Promise<void>) \| undefined`
`apiOptions?`	`SlackApiOptions`	—
For tests: a different Slack API URL or `fetch`. `SlackApiOptions \| undefined`

import { whatsappChannel } from "@intentface/latch-channels/whatsapp";

Option	Type	Default
`agent`	`string`	—
The agent this number answers as, by name. `string`
`botRef`	`string`	—
Your own id for this number. Chat ids are built from it (`whatsapp_<botRef>_<waId>`), so changing credentials keeps every conversation. `string`
`accessToken`	`LazyString`	—
Meta's access token for the WhatsApp Cloud API, or a function that reads it. `LazyString`
`phoneNumberId`	`LazyString`	—
The WhatsApp phone number id from Meta. `LazyString`
`appSecret`	`LazyString`	—
The Meta app secret; webhook requests not signed with it are refused. `LazyString`
`verifyToken`	`LazyString`	—
The verify token you entered when setting up the webhook in Meta. `LazyString`
`runtime`	`ChannelRunOps<P>`	—
Your runtime. `ChannelRunOps<P>`
`authorizeUser`	`(user: WhatsappUser) => Promise<AuthResult<P>>`	—
Who this WhatsApp user is in your app. Return `{ allowed: true, principal }`, or `{ allowed: false, linkUrl }` to send them a link to connect their account. Runs on every message. `(user: WhatsappUser) => Promise<AuthResult<P>>`
`seen?`	`((deliveryKey: string) => Promise<boolean>)`	—
Returns `true` if this delivery was seen before, and records it if not. Meta resends webhooks; back this with a table with an expiry. `((deliveryKey: string) => Promise<boolean>) \| undefined`
`claimTurn?`	`((chatId: string) => Promise<string \| null>)`	—
Only for a storage adapter that doesn't refuse a second answer per chat itself; the built-in ones do. `((chatId: string) => Promise<string \| null>) \| undefined`
`releaseTurn?`	`((chatId: string, token: string) => Promise<void>)`	—
`((chatId: string, token: string) => Promise<void>) \| undefined`
`stashPending?`	`function`	—
Keeps the message from a user who still has to connect their account, to answer after they do. `((input: WhatsappUser & { text: string; media?: InboundMedia<WaMediaRef>[]; }) => Promise<void>) \| undefined`
`authorizeUrl?`	`function`	—
The URL that starts signing in to a service when the agent asks the user to connect it. `((connectionName: string, ctx: { chatId: string; waId: string; approvalId: string; }) => string) \| undefined`
`askState?`	`AskStateStore`	—
Keeps the state of a question the agent asked with buttons, between taps. `AskStateStore \| undefined`
`thread?`	`ChannelThreadStore`	—
Remembers the user's current conversation, so `/new` can start a fresh one. `ChannelThreadStore \| undefined`
`waitUntil?`	`((p: Promise<unknown>) => void)`	—
Keeps a serverless function running after the quick reply to Meta, for example Vercel's `waitUntil`. `((p: Promise<unknown>) => void) \| undefined`
`apiOptions?`	`WhatsappApiOptions`	—
For tests: a different Graph API URL or `fetch`. `WhatsappApiOptions \| undefined`