Agent events

Subscribe only to the events that your agent needs. The Agent SDK uses Node’s EventEmitter interface.

Event	Value
`message`	Every incoming message
`text`	Plain text
`markdown`	Markdown text
`attachment`	Remote attachment
`inline-attachment`	Inline attachment
`multi-attachment`	Multiple remote attachments
`reaction`	Reaction
`reply`	Enriched reply
`read-receipt`	Read receipt
`actions`	Actions prompt
`intent`	Selected action intent
`transaction-reference`	Transaction reference
`wallet-send-calls`	Wallet call request
`group-update`	Group membership or metadata update
`leave-request`	Leave request
`conversation`	New conversation
`dm`	New direct message conversation
`group`	New group conversation
`start`, `stop`	Agent lifecycle
`unhandledError`	Unhandled error
`unknownMessage`	Message with no specific event


const agent: Agent<BuiltInContentTypes>
agent.
NodeJS.EventEmitter<EventHandlerMap<BuiltInContentTypes>>.on<"text">(eventName: keyof EventHandlerMap<BuiltInContentTypes>, listener: (ctx: MessageContext<string, BuiltInContentTypes>) => void): Agent<BuiltInContentTypes>
Adds the listener function to the end of the listeners array for the event
named eventName. No checks are made to see if the listener has already
been added. Multiple calls passing the same combination of eventName and
listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
  console.log('someone connected!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
@since ― v0.1.101
@param ― eventName The name of the event.
@param ― listener The callback function
on("text", async (
ctx: MessageContext<string, BuiltInContentTypes>
ctx) => {
  await 
ctx: MessageContext<string, BuiltInContentTypes>
ctx.
MessageContext<string, BuiltInContentTypes>.sendTextReply(text: string): Promise<void>
Reply to this message with plain text content.
sendTextReply(`Echo: ${
ctx: MessageContext<string, BuiltInContentTypes>
ctx.
MessageContext<string, BuiltInContentTypes>.message: DecodedMessageWithContent<string>
Return the decoded message.
message.
content: string
The decoded content after the presence check.
content}`);
});

const agent: Agent<BuiltInContentTypes>
agent.
NodeJS.EventEmitter<EventHandlerMap<BuiltInContentTypes>>.on<"unhandledError">(eventName: keyof EventHandlerMap<BuiltInContentTypes>, listener: (error: Error) => void): Agent<BuiltInContentTypes>
Adds the listener function to the end of the listeners array for the event
named eventName. No checks are made to see if the listener has already
been added. Multiple calls passing the same combination of eventName and
listener will result in the listener being added, and called, multiple times.
server.on('connection', (stream) => {
  console.log('someone connected!');
});
Returns a reference to the EventEmitter, so that calls can be chained.
By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the
event listener to the beginning of the listeners array.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
@since ― v0.1.101
@param ― eventName The name of the event.
@param ― listener The callback function
on("unhandledError", (
error: Error
error) => {
  
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.error(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stderr with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const code = 5;
console.error('error #%d', code);
// Prints: error #5, to stderr
console.error('error', code);
// Prints: error 5, to stderr
If formatting elements (e.g. %d) are not found in the first string then
util.inspect() is called on each argument and the
resulting string values are concatenated. See util.format()
for more information.
@since ― v0.1.100
error(
error: Error
error);
});