Messaging SDK (Node)

1
import { MessagingClient } from '@astropods/messaging';
2
3
const client = new MessagingClient('localhost:9090');
4
await client.connect();
5
// or with retry/backoff:
6
await client.connectWithRetry({ maxRetries: 10 });

1
import { MessagingClient, AgentResponse } from '@astropods/messaging';
2
3
const client = new MessagingClient('localhost:9090');
4
await client.connect();
5
const conversation = client.createConversationStream();
6
7
conversation.on('response', (resp: AgentResponse) => {
8
  if (resp.incomingMessage) {
9
    const m = resp.incomingMessage;
10
    conversation.sendContentChunk(m.conversationId, {
11
      type: 'END',
12
      content: `you said: ${m.content}`,
13
    });
14
  }
15
});
16
17
conversation.on('error', (err) => console.error('stream error', err));
18
conversation.on('reconnecting', (info) => console.warn('reconnecting', info));

1
conversation.sendContentChunk(cid, { type: 'START', content: '' });
2
for await (const token of llm.stream(prompt)) {
3
  conversation.sendContentChunk(cid, { type: 'DELTA', content: token });
4
}
5
conversation.sendContentChunk(cid, { type: 'END', content: '' });

1
conversation.sendStatusUpdate(cid, { status: 'SEARCHING' });
2
conversation.sendStatusUpdate(cid, {
3
  status: 'CUSTOM',
4
  customMessage: 'Querying the knowledge base…',
5
  emoji: ':mag:',
6
});

1
conversation.on('response', (resp) => {
2
  if (resp.feedback?.reaction) {
3
    const { type, added } = resp.feedback.reaction;
4
    log({ kind: 'reaction', responseId: resp.feedback.responseId, type, added });
5
  }
6
  if (resp.feedback?.streamControl) {
7
    // Cancel in-flight generation for this conversation
8
  }
9
});

1
import { audioEncodingToFiletype } from '@astropods/messaging';
2
3
conversation.on('audioConfig', async (config) => {
4
  const audioStream = conversation.audioAsReadable();
5
  const filetype = audioEncodingToFiletype(config.encoding);  // 'webm' for WEBM_OPUS
6
  const transcript = await agent.voice.listen(audioStream, { filetype });
7
  conversation.sendTranscript(config.conversationId, transcript);
8
});

1
const history = await client.getThreadHistory(conversationId, 50);
2
for (const m of history.messages) {
3
  // m.content, m.wasEdited, m.isDeleted, m.originalContent, ...
4
}

1
const conversation = client.createConversationStream({
2
  maxRetries: 20,
3
  initialDelayMs: 500,
4
  maxDelayMs: 30_000,
5
  jitter: true,
6
  maxBufferSize: 1000,
7
});
8
9
conversation.on('reconnecting', ({ attempt, delayMs }) => { /* … */ });
10
conversation.on('reconnected',  ({ attempt }) => { /* … */ });

1
import { MessagingClient, AgentResponse, Message } from '@astropods/messaging';
2
3
const client = new MessagingClient('localhost:9090');
4
await client.connectWithRetry();
5
const conversation = client.createConversationStream();
6
7
async function handleSlackMessage(m: Message) {
8
  const cid = m.conversationId;
9
  const kind = m.platformContext?.eventKind;
10
11
  if (kind === 'EVENT_KIND_OBSERVED') return; // listen-only
12
13
  conversation.sendStatusUpdate(cid, { status: 'THINKING' });
14
15
  const openThread = kind === 'EVENT_KIND_APP_MENTION';
16
  conversation.sendContentChunk(cid, {
17
    type: 'START',
18
    content: '',
19
    options: openThread ? { createThread: true } : undefined,
20
  });
21
22
  for await (const token of streamLLM(m.content)) {
23
    conversation.sendContentChunk(cid, { type: 'DELTA', content: token });
24
  }
25
  conversation.sendContentChunk(cid, { type: 'END', content: '' });
26
27
  conversation.sendAgentResponse({
28
    conversationId: cid,
29
    prompts: {
30
      prompts: [
31
        { id: 'p1', title: 'Show example', message: 'Show me an example' },
32
        { id: 'p2', title: 'Go deeper',    message: 'Can you explain more?' },
33
      ],
34
    },
35
  });
36
}
37
38
conversation.on('response', (resp: AgentResponse) => {
39
  if (resp.incomingMessage?.platform === 'slack') {
40
    handleSlackMessage(resp.incomingMessage);
41
  }
42
43
  if (resp.feedback?.reaction) {
44
    const { type, added } = resp.feedback.reaction;
45
    recordFeedback({
46
      responseId: resp.feedback.responseId,
47
      kind: type === 1 ? 'up' : type === 2 ? 'down' : 'emoji',
48
      added,
49
      userId: resp.feedback.user?.id,
50
    });
51
  }
52
53
  if (resp.feedback?.promptSelection) {
54
    const text = (resp.feedback.promptSelection as any).promptMessage;
55
    handleSlackMessage({
56
      platform: 'slack',
57
      content: text,
58
      conversationId: resp.feedback.conversationId,
59
      user: resp.feedback.user!,
60
    } as Message);
61
  }
62
});

1
conversation.sendAgentResponse({
2
  conversationId: cid,
3
  content: {
4
    type: 'END',
5
    content: 'Deploy status:',
6
    attachments: [{
7
      card: {
8
        platformCardJson: JSON.stringify({
9
          blocks: [
10
            { type: 'header', text: { type: 'plain_text', text: 'Deploy #4837' } },
11
            { type: 'section', fields: [
12
              { type: 'mrkdwn', text: '*Status:*\n:white_check_mark: Green' },
13
              { type: 'mrkdwn', text: '*Region:*\nus-east-1' },
14
            ]},
15
            { type: 'actions', elements: [
16
              { type: 'button', text: { type: 'plain_text', text: 'View logs' },
17
                action_id: 'view_logs', value: 'deploy-4837' },
18
            ]},
19
          ],
20
        }),
21
      },
22
    }],
23
  },
24
});

1
import {
2
  MessagingClient, AgentResponse, Message,
3
  AudioStreamConfig, audioEncodingToFiletype,
4
} from '@astropods/messaging';
5
6
const client = new MessagingClient('localhost:9090');
7
await client.connectWithRetry();
8
const conversation = client.createConversationStream();
9
10
async function handleWebMessage(m: Message) {
11
  const cid = m.conversationId;
12
  conversation.sendStatusUpdate(cid, { status: 'GENERATING' });
13
  conversation.sendContentChunk(cid, { type: 'START', content: '' });
14
15
  for await (const token of streamLLM(m.content)) {
16
    conversation.sendContentChunk(cid, { type: 'DELTA', content: token });
17
  }
18
  conversation.sendContentChunk(cid, { type: 'END', content: '' });
19
}
20
21
conversation.on('audioConfig', async (config: AudioStreamConfig) => {
22
  const audioStream = conversation.audioAsReadable();
23
  const filetype = audioEncodingToFiletype(config.encoding);
24
  const transcript = await agent.voice.listen(audioStream, { filetype });
25
26
  conversation.sendTranscript(config.conversationId, transcript);
27
28
  handleWebMessage({
29
    platform: 'web',
30
    content: transcript,
31
    conversationId: config.conversationId,
32
    user: { id: config.userId ?? 'unknown' },
33
  } as Message);
34
});
35
36
conversation.on('response', (resp: AgentResponse) => {
37
  if (resp.incomingMessage?.platform === 'web') {
38
    handleWebMessage(resp.incomingMessage);
39
  }
40
41
  if (resp.feedback?.streamControl) {
42
    const action = (resp.feedback.streamControl as any).action;
43
    if (action === 1 /* STOP */) cancelGeneration(resp.feedback.conversationId);
44
  }
45
});

1
conversation.on('response', (resp) => {
2
  const m = resp.incomingMessage;
3
  if (!m) return;
4
5
  const openThread =
6
    m.platform === 'slack' &&
7
    m.platformContext?.eventKind === 'EVENT_KIND_APP_MENTION';
8
9
  conversation.sendContentChunk(m.conversationId, {
10
    type: 'START',
11
    content: '',
12
    options: openThread ? { createThread: true } : undefined,
13
  });
14
  // …rest of the loop is identical for Slack and web
15
});

1
// Client
2
MessagingClient
3
ConversationStream
4
MessageStream
5
Helpers                  // createMessage, createStatusResponse, createContentResponse, ...
6
7
// Types
8
Message, User, Attachment, PlatformContext, PlatformContextEventKind, Timestamp
9
AgentResponse, ContentChunk, StatusUpdate, SuggestedPrompts, ThreadMetadata
10
ErrorResponse, Transcript, ThreadHistoryRequest, ThreadHistoryResponse, ThreadMessage
11
AgentConfig, AgentToolConfig, AgentToolGraph
12
PlatformFeedback, MessageReaction, TextFeedback
13
AudioStreamConfig, AudioChunk, AudioEncoding, audioEncodingToFiletype
14
ConversationRequest, ReconnectOptions