Initiate outbound conversations

1
from tac import TAC, TACConfig
2
from tac.channels.sms import SMSChannel, SMSChannelConfig
3
from tac.models.outbound import InitiateMessagingConversationOptions
4
from tac.server import TACFastAPIServer
5

6
tac = TAC(config=TACConfig.from_env())
7
sms_channel = SMSChannel(tac, config=SMSChannelConfig(memory_mode="always"))
8

9
async def handle_message_ready(message, context, memory):
10
    # Called when the customer replies
11
    llm_response = await your_llm.generate(message)
12
    return llm_response
13

14
tac.on_message_ready(handle_message_ready)
15

16
# Initiate outbound SMS after server starts
17
result = await sms_channel.initiate_outbound_conversation(
18
    InitiateMessagingConversationOptions(
19
        to="+16505551234",
20
        message="Hi! This is Acme Corp. Your order has shipped.",
21
    )
22
)
23
print(f"Conversation started: {result.conversation_id}")
24

25
# Start the TACFastAPIServer to receive replies
26
server = TACFastAPIServer(tac=tac, messaging_channels=[sms_channel])
27
server.start()

1
import { TAC, TACConfig, SMSChannel, TACServer } from 'twilio-agent-connect';
2

3
const tac = await TAC.create({ config: TACConfig.fromEnv() });
4
const smsChannel = new SMSChannel(tac);
5
tac.registerChannel(smsChannel);
6

7
tac.onMessageReady(async ({ message }) => {
8
  // Called when the customer replies
9
  const llmResponse = await yourLLM.generate(message);
10
  return llmResponse;
11
});
12

13
// Start the TACServer to receive replies
14
const server = new TACServer(tac);
15
await server.start();
16

17
// Initiate outbound SMS
18
const result = await smsChannel.initiateOutboundConversation({
19
  to: '+16505551234',
20
  message: 'Hi! This is Acme Corp. Your order has shipped.',
21
});
22
console.log(`Conversation started: ${result.conversationId}`);

1
import os
2
from tac import TAC, TACConfig
3
from tac.channels.voice import VoiceChannel, VoiceChannelConfig
4
from tac.models.outbound import InitiateVoiceConversationOptions
5
from tac.server import TACFastAPIServer
6
from tac.server.config import TACServerConfig
7

8
tac = TAC(config=TACConfig.from_env())
9
voice_channel = VoiceChannel(tac, config=VoiceChannelConfig(memory_mode="always"))
10

11
async def handle_message_ready(message, context, memory):
12
    llm_response = await your_llm.generate(message)
13
    return llm_response
14

15
tac.on_message_ready(handle_message_ready)
16

17
# Get public domain for WebSocket URL
18
server_config = TACServerConfig.from_env()
19
public_domain = server_config.public_domain
20

21
# Initiate outbound voice call
22
result = await voice_channel.initiate_outbound_conversation(
23
    InitiateVoiceConversationOptions(
24
        to="+16505551234",
25
        websocket_url=f"wss://{public_domain}/ws",
26
        welcome_greeting="Hi! This is an AI assistant calling from Acme Corp.",
27
        action_url=f"https://{public_domain}/conversation-relay-callback",
28
    )
29
)
30
print(f"Call placed: {result.call_sid}")
31

32
# Start the TACFastAPIServer to handle the call
33
server = TACFastAPIServer(tac=tac, voice_channel=voice_channel)
34
server.start()

1
import { TAC, TACConfig, VoiceChannel, TACServer } from 'twilio-agent-connect';
2

3
const tac = await TAC.create({ config: TACConfig.fromEnv() });
4
const voiceChannel = new VoiceChannel(tac);
5
tac.registerChannel(voiceChannel);
6

7
tac.onMessageReady(async ({ message }) => {
8
  const llmResponse = await yourLLM.generate(message);
9
  return llmResponse;
10
});
11

12
// Start the TACServer to handle the call
13
const server = new TACServer(tac);
14
await server.start();
15

16
// Initiate outbound voice call
17
const publicDomain = process.env.TWILIO_VOICE_PUBLIC_DOMAIN!;
18
const result = await voiceChannel.initiateOutboundConversation({
19
  to: '+16505551234',
20
  conversationRelayConfig: {
21
    url: `wss://${publicDomain}/ws`,
22
    welcomeGreeting: 'Hi! This is an AI assistant calling from Acme Corp.',
23
  },
24
});
25
console.log(`Call placed: ${result.callSid}`);

1
from tac.channels.whatsapp import WhatsAppChannel, WhatsAppChannelConfig
2
from tac.channels.rcs import RCSChannel, RCSChannelConfig
3
from tac.models.outbound import InitiateMessagingConversationOptions
4

5
# WhatsApp — requires TWILIO_WHATSAPP_NUMBER env var
6
whatsapp_channel = WhatsAppChannel(tac, config=WhatsAppChannelConfig(memory_mode="always"))
7

8
result = await whatsapp_channel.initiate_outbound_conversation(
9
    InitiateMessagingConversationOptions(
10
        to="whatsapp:+16505551234",
11
        message="Hi! Your appointment is confirmed for tomorrow at 2pm.",
12
    )
13
)
14

15
# RCS — requires TWILIO_RCS_SENDER_ID env var
16
rcs_channel = RCSChannel(tac, config=RCSChannelConfig(memory_mode="always"))
17

18
result = await rcs_channel.initiate_outbound_conversation(
19
    InitiateMessagingConversationOptions(
20
        to="+16505551234",
21
        message="Hi! Your appointment is confirmed for tomorrow at 2pm.",
22
    )
23
)

1
import { WhatsAppChannel, RCSChannel } from 'twilio-agent-connect';
2

3
// WhatsApp — requires TWILIO_WHATSAPP_NUMBER env var
4
const whatsAppChannel = new WhatsAppChannel(tac);
5
tac.registerChannel(whatsAppChannel);
6

7
const waResult = await whatsAppChannel.initiateOutboundConversation({
8
  to: 'whatsapp:+16505551234',
9
  message: 'Hi! Your appointment is confirmed for tomorrow at 2pm.',
10
});
11

12
// RCS — requires TWILIO_RCS_SENDER_ID env var
13
const rcsChannel = new RCSChannel(tac);
14
tac.registerChannel(rcsChannel);
15

16
const rcsResult = await rcsChannel.initiateOutboundConversation({
17
  to: 'rcs:+16505551234',
18
  message: 'Hi! Your appointment is confirmed for tomorrow at 2pm.',
19
});