Channels

1
from tac.channels.voice import VoiceChannel, VoiceChannelConfig
2

3
voice_channel = VoiceChannel(
4
    tac,
5
    config=VoiceChannelConfig(
6
        memory_mode="always",
7
    ),
8
)

1
import { VoiceChannel } from 'twilio-agent-connect';
2

3
const voiceChannel = new VoiceChannel(tac);

1
async def handle_message_ready(
2
    message: str,
3
    context: ConversationSession,
4
    memory: TACMemoryResponse | None,
5
) -> str | None:
6
    llm_response = await generate_response(message)
7

8
    await voice_channel.send_response(
9
        conversation_id=context.conversation_id,
10
        response=llm_response,
11
    )

1
tac.onMessageReady(async ({ conversationId, message, channel }) => {
2
  const llmResponse = await generateResponse(message);
3

4
  if (channel === 'voice') {
5
    await voiceChannel.sendResponse(conversationId, llmResponse);
6
  }
7
});

1
async def handle_interrupt(
2
    context: ConversationSession,
3
    interrupt_data,
4
) -> None:
5
    # Cancel any pending operations for this conversation
6
    await cancel_pending_operations(context.conversation_id)
7

8
tac.on_interrupt(handle_interrupt)

1
tac.onInterrupt(async ({ conversationId, utteranceUntilInterrupt, durationUntilInterruptMs, session }) => {
2
  // Cancel any pending operations for this conversation
3
  await cancelPendingOperations(conversationId);
4
});

1
from tac.channels.sms import SMSChannel, SMSChannelConfig
2

3
sms_channel = SMSChannel(
4
    tac,
5
    config=SMSChannelConfig(
6
        memory_mode="always",
7
    ),
8
)
9

10
async def handle_message_ready(
11
    message: str,
12
    context: ConversationSession,
13
    memory: TACMemoryResponse | None,
14
) -> str | None:
15
    llm_response = await generate_response(message)
16

17
    await sms_channel.send_response(
18
        conversation_id=context.conversation_id,
19
        response=llm_response,
20
    )

1
import { SMSChannel } from 'twilio-agent-connect';
2

3
const smsChannel = new SMSChannel(tac);
4

5
tac.onMessageReady(async ({ conversationId, message, channel }) => {
6
  const llmResponse = await generateResponse(message);
7

8
  if (channel === 'sms') {
9
    await smsChannel.sendResponse(conversationId, llmResponse);
10
  }
11
});

1
from tac.channels.whatsapp import WhatsAppChannel, WhatsAppChannelConfig
2

3
whatsapp_channel = WhatsAppChannel(
4
    tac,
5
    config=WhatsAppChannelConfig(
6
        memory_mode="always",
7
    ),
8
)

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

3
const whatsAppChannel = new WhatsAppChannel(tac);
4
tac.registerChannel(whatsAppChannel);

1
from tac.channels.rcs import RCSChannel, RCSChannelConfig
2

3
rcs_channel = RCSChannel(
4
    tac,
5
    config=RCSChannelConfig(
6
        memory_mode="always",
7
    ),
8
)

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

3
const rcsChannel = new RCSChannel(tac);
4
tac.registerChannel(rcsChannel);

1
async def handle_message_ready(
2
    message: str,
3
    context: ConversationSession,
4
    memory: TACMemoryResponse | None,
5
) -> str | None:
6
    llm_response = await generate_response(message)
7
    return llm_response
8

9
tac.on_message_ready(handle_message_ready)

1
tac.onMessageReady(async ({ message, memory }) => {
2
  const llmResponse = await generateResponse(message);
3
  return llmResponse;
4
});

1
async def handle_message_ready(
2
    message: str,
3
    context: ConversationSession,
4
    memory: TACMemoryResponse | None,
5
) -> str | None:
6
    if context.channel == "voice":
7
        return await generate_response(message, max_tokens=100)
8
    else:
9
        return await generate_response(message)
10

11
tac.on_message_ready(handle_message_ready)

1
tac.onMessageReady(async ({ message, channel }) => {
2
  if (channel === 'voice') {
3
    return await generateResponse(message, { maxTokens: 100 });
4
  }
5
  return await generateResponse(message);
6
});

1
# Manual memory retrieval
2
memory = await tac.retrieve_memory(context, query="customer preferences")

1
// Manual memory retrieval
2
const memory = await tac.retrieveMemory(session, 'customer preferences');

1
async def handle_conversation_ended(context: ConversationSession) -> None:
2
    # Clean up resources for this conversation
3
    conversation_history.pop(context.conversation_id, None)
4

5
tac.on_conversation_ended(handle_conversation_ended)

1
tac.onConversationEnded(async ({ session }) => {
2
  // Clean up resources for this conversation
3
  delete conversationHistory[session.conversationId];
4
});