Actions and intents

Actions let a sender present choices. An intent carries the recipient’s selected action.

Actions

Type ID: coinbase.com/actions:1.0. The payload is JSON-encoded Actions. Its fallback contains the description, a numbered action list, and an instruction to reply with a number. shouldPush defaults to true on Browser and Node. Kotlin and Swift do not include this codec.

An actions message contains 1 to 10 actions. Each action has a unique id, a label, an optional image URL, and a style. The style is primary, secondary, or danger. Both the message and each action can have an expiry. Clients enforce expiry.

Actions field	Meaning
`id`	Action set ID
`description`	Text shown before the choices
`actions`	1 to 10 action entries
`expiresAt`	Optional expiry for the full set

Action field	Meaning
`id`	Unique action ID
`label`	Display label
`imageUrl`	Optional image URL
`style`	Optional `primary`, `secondary`, or `danger` style
`expiresAt`	Optional expiry for this action

Intents

Type ID: coinbase.com/intent:1.0. The payload is JSON-encoded Intent with an ID, action ID, and optional metadata. Metadata is limited to 10 KiB. Its fallback names the selected action. shouldPush defaults to true on Browser and Node. Kotlin and Swift do not include this codec.

Intent field	Meaning
`id`	Intent ID
`actionId`	Selected action ID
`metadata`	Optional JSON metadata, at most 10 KiB

The Agent SDK receives selections with the intent event. Its text fallback numbers the available actions so a client without actions support can still show the choices.


const agent: Agent<BuiltInContentTypes>
agent.
NodeJS.EventEmitter<EventHandlerMap<BuiltInContentTypes>>.on<"intent">(eventName: keyof EventHandlerMap<BuiltInContentTypes>, listener: (ctx: MessageContext<Intent, 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("intent", async (
ctx: MessageContext<Intent, BuiltInContentTypes>
ctx) => {
  
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.log(message?: any, ...optionalParams: any[]): void (+1 overload)
Prints to stdout 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 count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(`Selected action: ${
ctx: MessageContext<Intent, BuiltInContentTypes>
ctx.
MessageContext<Intent, BuiltInContentTypes>.message: DecodedMessageWithContent<Intent>
Return the decoded message.
message.
content: Intent
The decoded content after the presence check.
content.
Intent.actionId: string
actionId}`);
});