Chat - Photon

// Define custom thread state type
interface MyThreadState {
  aiMode?: boolean;
  userName?: string;
}

const chat = new Chat<typeof adapters, MyThreadState>({
  userName: "mybot",
  adapters: {
    slack: createSlackAdapter({ ... }),
    teams: createTeamsAdapter({ ... }),
  },
  state: createMemoryState(),
});

// Type-safe thread state
chat.onNewMention(async (thread, message) => {
  await thread.setState({ aiMode: true });
  const state = await thread.state; // Type: MyThreadState | null
});

class Chat implements ChatInstance

Constructor

Chat(config: ChatConfig<TAdapters>): Chat<TAdapters, TState>

Parameters

ChatConfig<TAdapters>

required

Type: ChatConfig

Returns

Chat

Properties

HistoryApi

required

Unified History API. Sub-APIs:

history.user — cross-platform per-user transcript store (throws if not configured)
history.thread — per-thread message listing
history.channel — channel-level messages and thread listings

TranscriptsApi

required

Cross-platform per-user transcript store. Deprecated alias for ChatInstance.history.user — throws on access when user history was not configured (history.user or legacy transcripts + identity).

Deprecated: Use ChatInstance.history.user instead.

Webhooks<TAdapters>

required

Type-safe webhook handlers keyed by adapter name.

chat.webhooks.slack(request, { backgroundTask: waitUntil });

Methods

abortTurn()

abortTurn(threadId: string): Promise<void>

Abort active work for a conversation, including work running in another process that shares the configured state adapter.

Parameters

string

required

Returns

Promise<void>

channel()

channel(channelId: string): Channel<TState>

Get a Channel by its channel ID. The adapter is automatically inferred from the channel ID prefix.

const channel = chat.channel("slack:C123ABC");

// Iterate messages newest first
for await (const msg of channel.messages) {
  console.log(msg.text);
}

// List threads
for await (const t of channel.threads()) {
  console.log(t.rootMessage.text, t.replyCount);
}

// Post to channel
await channel.post("Hello channel!");

Parameters

string

required

Channel ID (e.g., “slack:C123ABC”, “gchat:spaces/ABC123”)

Returns

Channel A Channel that can be used to list threads, post messages, iterate messages, etc.

getAdapter()

getAdapter(name: K): TAdapters[K]

Get an adapter by name with type safety.

Parameters

required

Returns

TAdapters[K]

getLogger()

getLogger(prefix?: string): Logger

Get the configured logger, optionally with a child prefix

Parameters

string

Returns

Logger

getSingleton()

getSingleton(): Chat

Get the registered singleton Chat instance. Throws if no singleton has been registered.

Returns

Chat

getState()

getState(): StateAdapter

Returns

StateAdapter

getUser()

getUser(user: string | Author): Promise<UserInfo | null>

Look up user information by user ID. The adapter is automatically inferred from the user ID format. Returns user details including email (where available — requires appropriate scopes on some platforms, e.g. users:read.email on Slack).

const user = await chat.getUser("U123456");
console.log(user?.email); // "[email protected]"

Parameters

string | Author

required

Type: AuthorPlatform-specific user ID string, or an Author object

Returns

UserInfo User info, or null if user not found

getUserName()

getUserName(): string

Returns

string

handleIncomingMessage()

handleIncomingMessage(adapter: Adapter, threadId: string, message: Message): Promise<void>

Handle an incoming message from an adapter. This is called by adapters when they receive a webhook. The Chat class handles common concerns centrally:

Deduplication: Same message may arrive multiple times (e.g., Slack sends both message and app_mention events, GChat sends direct webhook + Pub/Sub)
Bot filtering: Messages from the bot itself are skipped
Concurrency: Controlled by concurrency config (drop, queue, debounce, burst, concurrent)

Parameters

Adapter

required

string

required

Message

required

Returns

Promise<void>

hasSingleton()

hasSingleton(): boolean

Check if a singleton has been registered.

Returns

boolean

initialize()

initialize(): Promise<void>

Initialize the chat instance and all adapters. This is called automatically when handling webhooks, but can be called manually for non-webhook use cases (e.g., Gateway listeners).

Returns

Promise<void>

onAction()

onAction(handler: ActionHandler): void

// Handle specific action
chat.onAction("approve", async (event) => {
  await event.thread.post("Approved!");
});

// Handle multiple actions
chat.onAction(["approve", "reject"], async (event) => {
  if (event.actionId === "approve") {
    await event.thread.post("Approved!");
  } else {
    await event.thread.post("Rejected!");
  }
});

// Handle all actions (catch-all)
chat.onAction(async (event) => {
  console.log(`Action: ${event.actionId}`);
});

Parameters

ActionHandler

required

The handler (if action ID filter is provided)

onAction(actionIds: string | string[], handler: ActionHandler): void

// Handle specific action
chat.onAction("approve", async (event) => {
  await event.thread.post("Approved!");
});

// Handle multiple actions
chat.onAction(["approve", "reject"], async (event) => {
  if (event.actionId === "approve") {
    await event.thread.post("Approved!");
  } else {
    await event.thread.post("Rejected!");
  }
});

// Handle all actions (catch-all)
chat.onAction(async (event) => {
  console.log(`Action: ${event.actionId}`);
});

Parameters

string | string[]

required

ActionHandler

required

The handler (if action ID filter is provided)

onAgentSessionStopped()

onAgentSessionStopped(handler: AgentSessionStoppedHandler): void

Parameters

AgentSessionStoppedHandler

required

onAgentSessionTitleChanged()

onAgentSessionTitleChanged(handler: AgentSessionTitleChangedHandler): void

Parameters

AgentSessionTitleChangedHandler

required

onAppContextChanged()

onAppContextChanged(handler: AppContextChangedHandler): void

Parameters

AppContextChangedHandler

required

onAppHomeOpened()

onAppHomeOpened(handler: AppHomeOpenedHandler): void

Parameters

AppHomeOpenedHandler

required

onAssistantContextChanged()

onAssistantContextChanged(handler: AssistantContextChangedHandler): void

Parameters

AssistantContextChangedHandler

required

onAssistantThreadStarted()

onAssistantThreadStarted(handler: AssistantThreadStartedHandler): void

Parameters

AssistantThreadStartedHandler

required

onDirectMessage()

onDirectMessage(handler: DirectMessageHandler<TState>): void

Register a handler for direct messages. Called for every message received in a DM thread when at least one direct message handler is registered. Direct message handlers run before onSubscribedMessage, onNewMention, and pattern handlers. If no onDirectMessage handlers are registered, DMs continue through normal routing. Unsubscribed DMs fall through to onNewMention for backward compatibility.

chat.onDirectMessage(async (thread, message) => {
  await thread.subscribe();
  await thread.post("Thanks for the DM!");
});

Parameters

DirectMessageHandler<TState>

required

Type: DirectMessageHandlerHandler called for DM messages

onInstalled()

onInstalled(handler: InstalledHandler): void

Handle bot installation, including upgrades that add the bot (currently Teams only).

Parameters

InstalledHandler

required

onMemberJoinedChannel()

onMemberJoinedChannel(handler: MemberJoinedChannelHandler): void

Parameters

MemberJoinedChannelHandler

required

onMessageDeleted()

onMessageDeleted(handler: MessageDeletedHandler): void

Register a handler for message delete events. Delete events usually do not include the deleted message body. Handlers get the normalized platform IDs needed to update external storage.

Parameters

MessageDeletedHandler

required

onMessageUpdated()

onMessageUpdated(handler: MessageUpdatedHandler<TState>): void

Register a handler for message edit/update events. These lifecycle events are dispatched directly by adapters and do not route through onNewMessage, onNewMention, or onSubscribedMessage.

Parameters

MessageUpdatedHandler<TState>

required

Type: MessageUpdatedHandler

onModalClose()

onModalClose(handler: ModalCloseHandler): void

// Handle specific modal close
chat.onModalClose("settings-modal", async (event) => {
  console.log("User cancelled settings");
});

// Handle all modal close events
chat.onModalClose(async (event) => {
  console.log(`Modal ${event.callbackId} closed`);
});

Parameters

ModalCloseHandler

required

The handler (if callback ID filter is provided)

onModalClose(callbackIds: string | string[], handler: ModalCloseHandler): void

// Handle specific modal close
chat.onModalClose("settings-modal", async (event) => {
  console.log("User cancelled settings");
});

// Handle all modal close events
chat.onModalClose(async (event) => {
  console.log(`Modal ${event.callbackId} closed`);
});

Parameters

string | string[]

required

ModalCloseHandler

required

The handler (if callback ID filter is provided)

onModalSubmit()

onModalSubmit(handler: ModalSubmitHandler): void

// Handle specific modal
chat.onModalSubmit("settings-modal", async (event) => {
  const name = event.values["name"];
  await event.relatedThread?.post(`Updated name to ${name}`);
});

// Handle all modal submissions
chat.onModalSubmit(async (event) => {
  console.log(`Modal ${event.callbackId} submitted`);
});

Parameters

ModalSubmitHandler

required

The handler (if callback ID filter is provided)

onModalSubmit(callbackIds: string | string[], handler: ModalSubmitHandler): void

// Handle specific modal
chat.onModalSubmit("settings-modal", async (event) => {
  const name = event.values["name"];
  await event.relatedThread?.post(`Updated name to ${name}`);
});

// Handle all modal submissions
chat.onModalSubmit(async (event) => {
  console.log(`Modal ${event.callbackId} submitted`);
});

Parameters

string | string[]

required

ModalSubmitHandler

required

The handler (if callback ID filter is provided)

onNewMention()

onNewMention(handler: MentionHandler<TState>): void

Register a handler for new @-mentions of the bot. Important: This handler is ONLY called for mentions in unsubscribed threads. Once a thread is subscribed (via thread.subscribe()), subsequent messages including @-mentions go to onSubscribedMessage handlers instead. To detect mentions in subscribed threads, check message.isMention:

// Handle new mentions (unsubscribed threads only)
chat.onNewMention(async (thread, message) => {
  await thread.subscribe();  // Subscribe to follow-up messages
  await thread.post("Hello! I'll be watching this thread.");
});

// Handle all messages in subscribed threads
chat.onSubscribedMessage(async (thread, message) => {
  if (message.isMention) {
    // User @-mentioned us in a thread we're already watching
    await thread.post("You mentioned me again!");
  }
});

Parameters

MentionHandler<TState>

required

Type: MentionHandler

onNewMessage()

onNewMessage(pattern: RegExp, handler: MessageHandler<TState>): void

// Match messages starting with "!help"
chat.onNewMessage(/^!help/, async (thread, message) => {
  await thread.post("Available commands: !help, !status, !ping");
});

Parameters

RegExp

required

Regular expression to match against message text

MessageHandler<TState>

required

Type: MessageHandlerHandler called when pattern matches

onOptionsLoad()

onOptionsLoad(handler: OptionsLoadHandler): void

Parameters

OptionsLoadHandler

required

onOptionsLoad(actionIds: string | string[], handler: OptionsLoadHandler): void

Parameters

string | string[]

required

OptionsLoadHandler

required

onReaction()

onReaction(handler: ReactionHandler): void

// Handle specific emoji using EmojiValue objects (recommended)
chat.onReaction([emoji.thumbs_up, emoji.heart], async (event) => {
  if (event.emoji === emoji.thumbs_up) {
    console.log("Thumbs up!");
  }
});

// Handle all reactions
chat.onReaction(async (event) => {
  console.log(`${event.added ? "Added" : "Removed"} ${event.emoji.name}`);
});

Parameters

ReactionHandler

required

The handler (if emoji filter is provided)

onReaction(emoji: EmojiFilter[], handler: ReactionHandler): void

// Handle specific emoji using EmojiValue objects (recommended)
chat.onReaction([emoji.thumbs_up, emoji.heart], async (event) => {
  if (event.emoji === emoji.thumbs_up) {
    console.log("Thumbs up!");
  }
});

// Handle all reactions
chat.onReaction(async (event) => {
  console.log(`${event.added ? "Added" : "Removed"} ${event.emoji.name}`);
});

Parameters

EmojiFilter[]

required

ReactionHandler

required

The handler (if emoji filter is provided)

onSlashCommand()

onSlashCommand(handler: SlashCommandHandler<TState>): void

Register a handler for slash command events. Slash commands are triggered when a user types /command in the message composer. Use event.channel.post() or event.channel.postEphemeral() to respond.

// Handle a specific command
chat.onSlashCommand("/help", async (event) => {
  await event.channel.post("Here are the available commands...");
});

// Handle multiple commands
chat.onSlashCommand(["/status", "/health"], async (event) => {
  await event.channel.post("All systems operational!");
});

// Handle all commands (catch-all)
chat.onSlashCommand(async (event) => {
  console.log(`Received command: ${event.command} ${event.text}`);
});

// Open a modal from a slash command
chat.onSlashCommand("/feedback", async (event) => {
  await event.openModal({
    callbackId: "feedback_modal",
    title: "Submit Feedback",
    inputs: [{ id: "feedback", type: "text_input", label: "Your feedback" }],
  });
});

Parameters

SlashCommandHandler<TState>

required

Type: SlashCommandHandlerThe handler (if command filter is provided)

onSlashCommand(commands: string | string[], handler: SlashCommandHandler<TState>): void

// Handle a specific command
chat.onSlashCommand("/help", async (event) => {
  await event.channel.post("Here are the available commands...");
});

// Handle multiple commands
chat.onSlashCommand(["/status", "/health"], async (event) => {
  await event.channel.post("All systems operational!");
});

// Handle all commands (catch-all)
chat.onSlashCommand(async (event) => {
  console.log(`Received command: ${event.command} ${event.text}`);
});

// Open a modal from a slash command
chat.onSlashCommand("/feedback", async (event) => {
  await event.openModal({
    callbackId: "feedback_modal",
    title: "Submit Feedback",
    inputs: [{ id: "feedback", type: "text_input", label: "Your feedback" }],
  });
});

Parameters

string | string[]

required

SlashCommandHandler<TState>

required

Type: SlashCommandHandlerThe handler (if command filter is provided)

onSubscribedMessage()

onSubscribedMessage(handler: SubscribedMessageHandler<TState>): void

Register a handler for messages in subscribed threads. Called for all messages in threads that have been subscribed via thread.subscribe(). This includes:

Follow-up messages from users
Messages that @-mention the bot (check message.isMention)

Does NOT fire for:

The message that triggered the subscription (e.g., the initial @mention)
Messages sent by the bot itself

chat.onSubscribedMessage(async (thread, message) => {
  // Handle all follow-up messages
  if (message.isMention) {
    // User @-mentioned us in a subscribed thread
  }
  await thread.post(`Got your message: ${message.text}`);
});

Parameters

SubscribedMessageHandler<TState>

required

Type: SubscribedMessageHandler

onUninstalled()

onUninstalled(handler: UninstalledHandler): void

Handle bot removal, including upgrades that remove the bot (currently Teams only).

Parameters

UninstalledHandler

required

openDM()

openDM(user: string | Author): Promise<Thread<TState, unknown>>

Open a direct message conversation with a user. Accepts either a user ID string or an Author object (from message.author or event.user). The adapter is automatically inferred from the userId format:

Slack: U... (e.g., “U00FAKEUSER1”)
Teams: 29:... (e.g., “29:198PbJuw…”)
Google Chat: users/... (e.g., “users/100000000000000000001”)
Discord: numeric snowflake (e.g., “1033044521375764530”)

// Using user ID directly
const dmThread = await chat.openDM("U123456");
await dmThread.post("Hello via DM!");

// Using Author object from a message
chat.onSubscribedMessage(async (thread, message) => {
  const dmThread = await chat.openDM(message.author);
  await dmThread.post("Hello via DM!");
});

Parameters

string | Author

required

Type: AuthorPlatform-specific user ID string, or an Author object

Returns

Thread A Thread that can be used to post messages

processAction()

processAction(event: Omit<ActionEvent<unknown>, "thread" | "openModal"> & { adapter: Adapter }, options: WebhookOptions | undefined): Promise<void>

Process an incoming action event (button click) from an adapter. Handles waitUntil registration and error catching internally.

Parameters

Omit<ActionEvent<unknown>, "thread" | "openModal"> & { adapter: Adapter }

required

Type: ActionEventAdapter

WebhookOptions | undefined

required

Type: WebhookOptions

Returns

Promise<void>

processAgentSessionStopped()

processAgentSessionStopped(event: AgentSessionStoppedEvent, options?: WebhookOptions): void

Parameters

AgentSessionStoppedEvent

required

WebhookOptions

processAgentSessionTitleChanged()

processAgentSessionTitleChanged(event: AgentSessionTitleChangedEvent, options?: WebhookOptions): void

Parameters

AgentSessionTitleChangedEvent

required

WebhookOptions

processAppContextChanged()

processAppContextChanged(event: AppContextChangedEvent, options?: WebhookOptions): void

Parameters

AppContextChangedEvent

required

WebhookOptions

processAppHomeOpened()

processAppHomeOpened(event: AppHomeOpenedEvent, options?: WebhookOptions): void

Parameters

AppHomeOpenedEvent

required

WebhookOptions

processAssistantContextChanged()

processAssistantContextChanged(event: AssistantContextChangedEvent, options?: WebhookOptions): void

Parameters

AssistantContextChangedEvent

required

WebhookOptions

processAssistantThreadStarted()

processAssistantThreadStarted(event: AssistantThreadStartedEvent, options?: WebhookOptions): void

Parameters

AssistantThreadStartedEvent

required

WebhookOptions

processInstalled()

processInstalled(event: InstalledEvent, options?: WebhookOptions): void

Optional so custom ChatInstance implementations predating it keep compiling.

Parameters

InstalledEvent

required

WebhookOptions

processMemberJoinedChannel()

processMemberJoinedChannel(event: MemberJoinedChannelEvent, options?: WebhookOptions): void

Parameters

MemberJoinedChannelEvent

required

WebhookOptions

processMessage()

processMessage(adapter: Adapter, threadId: string, messageOrFactory: Message<unknown> | () => Promise<Message<unknown>>, options?: WebhookOptions): Promise<void>

Process an incoming message from an adapter. Handles waitUntil registration and error catching internally. Adapters should call this instead of handleIncomingMessage directly.

Parameters

Adapter

required

string

required

Message<unknown> | () => Promise<Message<unknown>>

required

Type: MessageMessage

WebhookOptions

Returns

Promise<void>

processMessageDeleted()

processMessageDeleted(event: Omit<MessageDeletedEvent<unknown>, "platform" | "adapter"> & { adapter: Adapter; platform: string }, options?: WebhookOptions): Promise<void>

Process an incoming message delete from an adapter. Handles waitUntil registration and error catching internally.

Parameters

Omit<MessageDeletedEvent<unknown>, "platform" | "adapter"> & { adapter: Adapter…

required

Type: MessageDeletedEventAdapter

WebhookOptions

Returns

Promise<void>

processMessageUpdated()

processMessageUpdated(event: { adapter: Adapter; message: Message<unknown> | () => Promise<Message<unknown>>; previousMessage: Message<unknown> | () => Promise<Message<unknown>>; threadId: string }, options?: WebhookOptions): Promise<void>

Process an incoming message update from an adapter. Handles waitUntil registration and error catching internally.

Parameters

{ adapter: Adapter; message: Message<unknown> | () => Promise<Message<unknown>>…

required

Type: AdapterMessageMessageMessageMessage

WebhookOptions

Returns

Promise<void>

processModalClose()

processModalClose(event: Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): void

Process a modal close event from an adapter.

Parameters

Omit<ModalCloseEvent, "relatedThread" | "relatedMessage" | "relatedChannel">

required

Type: ModalCloseEventThe modal close event (without relatedThread/relatedMessage/relatedChannel)

string

Context ID for retrieving stored thread/message/channel context

WebhookOptions

Webhook options

processModalSubmit()

processModalSubmit(event: Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage" | "relatedChannel">, contextId?: string, options?: WebhookOptions): Promise<ModalResponse | undefined>

Process a modal submit event from an adapter.

Parameters

Omit<ModalSubmitEvent, "relatedThread" | "relatedMessage" | "relatedChannel">

required

Type: ModalSubmitEventThe modal submit event (without relatedThread/relatedMessage/relatedChannel)

string

Context ID for retrieving stored thread/message/channel context

WebhookOptions

Webhook options

Returns

ModalResponse

processOptionsLoad()

processOptionsLoad(event: OptionsLoadEvent, _options?: WebhookOptions): Promise<OptionsLoadResult | undefined>

Process an interactive options load event from an adapter. Returns normalized select options for the adapter to render.

Parameters

OptionsLoadEvent

required

WebhookOptions

Returns

OptionsLoadResult

processReaction()

processReaction(event: Omit<ReactionEvent<unknown>, "thread" | "adapter"> & { adapter: Adapter<unknown, unknown> }, options?: WebhookOptions): Promise<void>

Process an incoming reaction event from an adapter. Handles waitUntil registration and error catching internally.

Parameters

Omit<ReactionEvent<unknown>, "thread" | "adapter"> & { adapter: Adapter<unknown…

required

Type: ReactionEventAdapter

WebhookOptions

Returns

Promise<void>

processSlashCommand()

processSlashCommand(event: Omit<SlashCommandEvent<Record<string, unknown>>, "channel" | "openModal"> & { adapter: Adapter; channelId: string }, options: WebhookOptions | undefined): Promise<void>

Process an incoming slash command from an adapter. Handles waitUntil registration and error catching internally.

Parameters

Omit<SlashCommandEvent<Record<string, unknown>>, "channel" | "openModal"> & { a…

required

Type: SlashCommandEventAdapter

WebhookOptions | undefined

required

Type: WebhookOptions

Returns

Promise<void>

processUninstalled()

processUninstalled(event: UninstalledEvent, options?: WebhookOptions): void

Optional so custom ChatInstance implementations predating it keep compiling.

Parameters

UninstalledEvent

required

WebhookOptions

registerSingleton()

registerSingleton(): this

const chat = new Chat({ ... });
chat.registerSingleton();

// Now threads can be deserialized without passing chat explicitly
const thread = ThreadImpl.fromJSON(serializedThread);

Returns

this

reviver()

reviver(): (key: string, value: unknown) => unknown

Get a JSON.parse reviver function that automatically deserializes chat:Thread and chat:Message objects. Use this when parsing JSON that contains serialized Thread or Message objects (e.g., from workflow engine payloads).

// Parse workflow payload with automatic deserialization
const data = JSON.parse(payload, chat.reviver());

// data.thread is now a ThreadImpl instance
// data.message is now a Message object with Date fields restored
await data.thread.post("Hello from workflow!");

Returns

(key: string, value: unknown) => unknown A reviver function for JSON.parse

shutdown()

shutdown(): Promise<void>

Gracefully shut down the chat instance.

Returns

Promise<void>

thread()

thread(threadId: string): Thread<TState>

Get a Thread handle by its thread ID. The adapter is automatically inferred from the thread ID prefix.

const thread = chat.thread("slack:C123ABC:1234567890.123456");
await thread.post("Hello from outside a webhook!");

Parameters

string

required

Full thread ID (e.g., “slack:C123ABC:1234567890.123456”)

Returns

Thread A Thread that can be used to post messages, subscribe, etc.

⌘I

​Constructor

​Parameters

​Returns

​Properties

​Methods

​abortTurn()

​Parameters

​Returns

​channel()

​Parameters

​Returns

​getAdapter()

​Parameters

​Returns

​getLogger()

​Parameters

​Returns

​getSingleton()

​Returns

​getState()

​Returns

​getUser()

​Parameters

​Returns

​getUserName()

​Returns

​handleIncomingMessage()

​Parameters

​Returns

​hasSingleton()

​Returns

​initialize()

​Returns

​onAction()

​Parameters

​Parameters

​onAgentSessionStopped()

​Parameters

​onAgentSessionTitleChanged()

​Parameters

​onAppContextChanged()

​Parameters

​onAppHomeOpened()

​Parameters

​onAssistantContextChanged()

​Parameters

​onAssistantThreadStarted()

​Parameters

​onDirectMessage()

​Parameters

​onInstalled()

​Parameters

​onMemberJoinedChannel()

​Parameters

​onMessageDeleted()

​Parameters

​onMessageUpdated()

​Parameters

​onModalClose()

​Parameters

​Parameters

​onModalSubmit()

​Parameters

​Parameters

​onNewMention()

​Parameters

​onNewMessage()

​Parameters

​onOptionsLoad()

​Parameters

​Parameters

​onReaction()

​Parameters

​Parameters

​onSlashCommand()

​Parameters

​Parameters

​onSubscribedMessage()

​Parameters

​onUninstalled()

Constructor

Parameters

Returns

Properties

Methods

abortTurn()

Parameters

Returns

channel()

Parameters

Returns

getAdapter()

Parameters

Returns

getLogger()

Parameters

Returns

getSingleton()

Returns

getState()

Returns

getUser()

Parameters

Returns

getUserName()

Returns

handleIncomingMessage()

Parameters

Returns

hasSingleton()

Returns

initialize()

Returns

onAction()

Parameters

Parameters

onAgentSessionStopped()

Parameters

onAgentSessionTitleChanged()

Parameters

onAppContextChanged()

Parameters

onAppHomeOpened()

Parameters

onAssistantContextChanged()

Parameters

onAssistantThreadStarted()

Parameters

onDirectMessage()

Parameters

onInstalled()

Parameters

onMemberJoinedChannel()

Parameters

onMessageDeleted()

Parameters

onMessageUpdated()

Parameters

onModalClose()

Parameters

Parameters

onModalSubmit()

Parameters

Parameters

onNewMention()

Parameters

onNewMessage()

Parameters

onOptionsLoad()

Parameters

Parameters

onReaction()

Parameters

Parameters

onSlashCommand()

Parameters

Parameters

onSubscribedMessage()

Parameters

onUninstalled()