elevenlabs-python / data /tests /test_convai.py
introvoyz045's picture
Migrated from GitHub
9410704 verified
Raw History Blame Contribute Delete
19.3 kB
from unittest.mock import MagicMock, patch
from elevenlabs.conversational_ai.conversation import (
Conversation,
AudioInterface,
ConversationInitiationData,
AgentChatResponsePartType,
MultimodalMessageClientToOrchestratorEvent,
)
import json
import time
class MockAudioInterface(AudioInterface):
def start(self, input_callback):
print("Audio interface started")
self.input_callback = input_callback
def stop(self):
print("Audio interface stopped")
def output(self, audio):
print(f"Would play audio of length: {len(audio)} bytes")
def interrupt(self):
print("Audio interrupted")
# Add test constants and helpers at module level
TEST_CONVERSATION_ID = "test123"
TEST_AGENT_ID = "test_agent"
def create_mock_websocket(messages=None):
"""Helper to create a mock websocket with predefined responses"""
mock_ws = MagicMock()
if messages is None:
messages = [
{
"type": "conversation_initiation_metadata",
"conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID},
},
{"type": "agent_response", "agent_response_event": {"agent_response": "Hello there!"}},
]
def response_generator():
for msg in messages:
yield json.dumps(msg)
while True:
yield '{"type": "keep_alive"}'
mock_ws.recv = MagicMock(side_effect=response_generator())
return mock_ws
def test_conversation_basic_flow():
# Mock setup
mock_ws = create_mock_websocket()
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
agent_response_callback = MagicMock()
test_user_id = "test_user_123"
# Setup the conversation with user_id passed directly to the constructor
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
user_id=test_user_id,
requires_auth=False,
audio_interface=MockAudioInterface(),
callback_agent_response=agent_response_callback,
)
# Run the test
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
# Add a wait for the callback to be called
timeout = 5 # 5 seconds timeout
start_time = time.time()
while not agent_response_callback.called and time.time() - start_time < timeout:
time.sleep(0.1)
conversation.end_session()
conversation.wait_for_session_end()
# Assertions - check the call was made with the right structure
send_calls = [call[0][0] for call in mock_ws.send.call_args_list]
init_messages = [json.loads(call) for call in send_calls if 'conversation_initiation_client_data' in call]
assert len(init_messages) == 1
init_message = init_messages[0]
assert init_message["type"] == "conversation_initiation_client_data"
assert init_message["custom_llm_extra_body"] == {}
assert init_message["conversation_config_override"] == {}
assert init_message["dynamic_variables"] == {}
assert init_message["source_info"]["source"] == "python_sdk"
assert "version" in init_message["source_info"]
assert init_message["user_id"] == test_user_id
agent_response_callback.assert_called_once_with("Hello there!")
assert conversation._conversation_id == TEST_CONVERSATION_ID
assert conversation.user_id == test_user_id
def test_conversation_with_auth():
# Mock setup
mock_client = MagicMock()
mock_client.conversational_ai.conversations.get_signed_url.return_value.signed_url = "wss://signed.url"
mock_ws = create_mock_websocket(
[
{
"type": "conversation_initiation_metadata",
"conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID},
}
]
)
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=True,
audio_interface=MockAudioInterface(),
)
# Run the test
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
conversation.end_session()
conversation.wait_for_session_end()
# Assertions
mock_client.conversational_ai.conversations.get_signed_url.assert_called_once_with(agent_id=TEST_AGENT_ID, environment=None)
def test_conversation_with_dynamic_variables():
# Mock setup
mock_ws = create_mock_websocket()
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
agent_response_callback = MagicMock()
dynamic_variables = {"name": "angelo"}
config = ConversationInitiationData(dynamic_variables=dynamic_variables)
# Setup the conversation
conversation = Conversation(
client=mock_client,
config=config,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=MockAudioInterface(),
callback_agent_response=agent_response_callback,
)
# Run the test
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
# Add a wait for the callback to be called
timeout = 5 # 5 seconds timeout
start_time = time.time()
while not agent_response_callback.called and time.time() - start_time < timeout:
time.sleep(0.1)
conversation.end_session()
conversation.wait_for_session_end()
# Assertions - check the call was made with the right structure
send_calls = [call[0][0] for call in mock_ws.send.call_args_list]
init_messages = [json.loads(call) for call in send_calls if 'conversation_initiation_client_data' in call]
assert len(init_messages) == 1
init_message = init_messages[0]
assert init_message["type"] == "conversation_initiation_client_data"
assert init_message["custom_llm_extra_body"] == {}
assert init_message["conversation_config_override"] == {}
assert init_message["dynamic_variables"] == {"name": "angelo"}
assert init_message["source_info"]["source"] == "python_sdk"
assert "version" in init_message["source_info"]
agent_response_callback.assert_called_once_with("Hello there!")
assert conversation._conversation_id == TEST_CONVERSATION_ID
def test_conversation_with_contextual_update():
# Mock setup
mock_ws = create_mock_websocket([])
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
# Setup the conversation
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=MockAudioInterface(),
)
# Run the test
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
time.sleep(0.1)
conversation.send_contextual_update("User appears to be looking at pricing page")
# Teardown
conversation.end_session()
conversation.wait_for_session_end()
# Assertions
expected = json.dumps({"type": "contextual_update", "text": "User appears to be looking at pricing page"})
mock_ws.send.assert_any_call(expected)
def test_conversation_wss_url_generation_without_get_environment():
from elevenlabs.core.client_wrapper import SyncClientWrapper
# Test with various base URL formats to ensure robustness
test_cases = [
("https://api.elevenlabs.io", "wss://api.elevenlabs.io"),
("https://api.us.elevenlabs.io", "wss://api.us.elevenlabs.io"),
("https://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io"),
("http://localhost:8000", "ws://localhost:8000"),
]
for base_url, expected_ws_base in test_cases:
# Create a real SyncClientWrapper to ensure it doesn't have get_environment method
mock_client = MagicMock()
mock_client._client_wrapper = SyncClientWrapper(
base_url=base_url,
api_key="test_key",
httpx_client=MagicMock(),
timeout=30.0
)
# Create conversation with requires_auth=False
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=MockAudioInterface()
)
try:
wss_url = conversation._get_wss_url()
# Verify the URL is correctly generated
expected_url = f"{expected_ws_base}/v1/convai/conversation?agent_id={TEST_AGENT_ID}&source=python_sdk&version="
assert wss_url.startswith(expected_url), f"URL should start with {expected_url}, got {wss_url}"
# Verify the URL contains version parameter
assert "version=" in wss_url, f"URL should contain version parameter, got {wss_url}"
except AttributeError as e:
if "get_environment" in str(e):
assert False
else:
raise # Re-raise if it's a different AttributeError
except Exception as e:
assert False, f"Unexpected error generating WebSocket URL: {e}"
def test_websocket_url_construction_edge_cases():
"""Test WebSocket URL construction edge cases, specifically for trailing slash handling."""
from elevenlabs.core.client_wrapper import SyncClientWrapper
from elevenlabs.conversational_ai.conversation import Conversation
from elevenlabs.realtime_tts import RealtimeTextToSpeechClient
# Test cases with various base URL formats
test_cases = [
# Base URLs without trailing slashes (the main edge case)
("https://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io"),
("https://api.elevenlabs.io", "wss://api.elevenlabs.io", "wss://api.elevenlabs.io"),
("http://localhost:8000", "ws://localhost:8000", "wss://localhost:8000"),
# Base URLs with trailing slashes (should still work)
("https://api.eu.residency.elevenlabs.io/", "wss://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io/"),
("https://api.elevenlabs.io/", "wss://api.elevenlabs.io", "wss://api.elevenlabs.io/"),
("http://localhost:8000/", "ws://localhost:8000", "wss://localhost:8000/"),
]
for base_url, expected_ws_base, expected_tts_ws_base in test_cases:
# Test conversation WebSocket URL construction
mock_client = MagicMock()
mock_client._client_wrapper = SyncClientWrapper(
base_url=base_url,
api_key="test_key",
httpx_client=MagicMock(),
timeout=30.0
)
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=MockAudioInterface()
)
# Test conversation URL generation
conv_url = conversation._get_wss_url()
expected_conv_url = f"{expected_ws_base}/v1/convai/conversation"
assert expected_conv_url in conv_url, f"Conversation URL should contain {expected_conv_url}, got {conv_url}"
# Ensure no double slashes in the path (except after the protocol)
url_path = conv_url.split("://", 1)[1] # Remove protocol
assert "//" not in url_path, f"URL should not contain double slashes in path: {conv_url}"
# Test realtime TTS WebSocket URL construction
realtime_client = RealtimeTextToSpeechClient(client_wrapper=mock_client._client_wrapper)
# Test the WebSocket base URL construction
# Note: realtime TTS always uses wss scheme, not ws
assert realtime_client._ws_base_url == expected_tts_ws_base, f"TTS WebSocket base URL should be {expected_tts_ws_base}, got {realtime_client._ws_base_url}"
# Test full URL construction using urljoin (simulating the actual method)
import urllib.parse
test_voice_id = "test_voice_123"
test_model = "eleven_turbo_v2_5"
test_format = "mp3_44100_128"
relative_path = f"v1/text-to-speech/{test_voice_id}/stream-input?model_id={test_model}&output_format={test_format}"
full_tts_url = urllib.parse.urljoin(realtime_client._ws_base_url, relative_path)
# For URLs with trailing slash, expect it to be preserved in the joined URL
expected_tts_url_base = expected_tts_ws_base.rstrip('/') + "/v1/text-to-speech/" + test_voice_id + "/stream-input"
assert expected_tts_url_base in full_tts_url, f"TTS URL should contain {expected_tts_url_base}, got {full_tts_url}"
# Ensure no double slashes in the path
tts_url_path = full_tts_url.split("://", 1)[1]
assert "//" not in tts_url_path, f"TTS URL should not contain double slashes in path: {full_tts_url}"
def test_conversation_streaming_text_response():
mock_ws = create_mock_websocket(
[
{
"type": "conversation_initiation_metadata",
"conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID},
},
{
"type": "agent_chat_response_part",
"text_response_part": {"text": "", "type": "start"},
},
{
"type": "agent_chat_response_part",
"text_response_part": {"text": "Hello", "type": "delta"},
},
{
"type": "agent_chat_response_part",
"text_response_part": {"text": " there", "type": "delta"},
},
{
"type": "agent_chat_response_part",
"text_response_part": {"text": "!", "type": "delta"},
},
{
"type": "agent_chat_response_part",
"text_response_part": {"text": "", "type": "stop"},
},
]
)
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
streaming_calls = []
def streaming_callback(text, part_type):
streaming_calls.append((text, part_type))
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=MockAudioInterface(),
callback_agent_chat_response_part=streaming_callback,
)
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
timeout = 5
start_time = time.time()
while len(streaming_calls) < 5 and time.time() - start_time < timeout:
time.sleep(0.1)
conversation.end_session()
conversation.wait_for_session_end()
assert len(streaming_calls) == 5, f"Expected 5 streaming calls, got {len(streaming_calls)}"
assert streaming_calls[0] == ("", AgentChatResponsePartType.START)
assert streaming_calls[1] == ("Hello", AgentChatResponsePartType.DELTA)
assert streaming_calls[2] == (" there", AgentChatResponsePartType.DELTA)
assert streaming_calls[3] == ("!", AgentChatResponsePartType.DELTA)
assert streaming_calls[4] == ("", AgentChatResponsePartType.STOP)
def test_text_only_mode_auto_sets_config():
"""When audio_interface is None, text_only should be auto-set in config."""
mock_ws = create_mock_websocket()
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
conversation = Conversation(
client=mock_client,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=None,
)
assert conversation.config.conversation_config_override.get("text_only") is True
with patch("elevenlabs.conversational_ai.conversation.connect") as mock_connect:
mock_connect.return_value.__enter__.return_value = mock_ws
conversation.start_session()
conversation.end_session()
conversation.wait_for_session_end()
send_calls = [call[0][0] for call in mock_ws.send.call_args_list]
init_messages = [json.loads(call) for call in send_calls if 'conversation_initiation_client_data' in call]
assert len(init_messages) == 1
assert init_messages[0]["conversation_config_override"]["text_only"] is True
def test_text_only_mode_preserves_explicit_override():
"""When user explicitly sets text_only=False, the override should be preserved."""
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
config = ConversationInitiationData(conversation_config_override={"text_only": False})
conversation = Conversation(
client=mock_client,
config=config,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=None,
)
assert conversation.config.conversation_config_override["text_only"] is False
def test_text_only_mode_does_not_mutate_original_config():
"""Setting text_only should not mutate the caller's original config dict."""
mock_client = MagicMock()
mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io"
original_override = {"some_setting": "value"}
config = ConversationInitiationData(conversation_config_override=original_override)
Conversation(
client=mock_client,
config=config,
agent_id=TEST_AGENT_ID,
requires_auth=False,
audio_interface=None,
)
assert "text_only" not in original_override
# The ConversationInitiationData object itself should also be unmodified
assert "text_only" not in config.conversation_config_override
def test_multimodal_message_file_id_dual_sends_file_and_files():
event = MultimodalMessageClientToOrchestratorEvent(text="hello", file_id="file_a")
assert event.to_dict() == {
"type": "multimodal_message",
"text": {"type": "user_message", "text": "hello"},
"file": {"type": "file_input", "file_id": "file_a"},
"files": [{"type": "file_input", "file_id": "file_a"}],
}
def test_multimodal_message_file_ids_wins_and_dual_sends():
event = MultimodalMessageClientToOrchestratorEvent(file_id="ignored", file_ids=["file_a", "file_b"])
assert event.to_dict() == {
"type": "multimodal_message",
"file": {"type": "file_input", "file_id": "file_a"},
"files": [
{"type": "file_input", "file_id": "file_a"},
{"type": "file_input", "file_id": "file_b"},
],
}
def test_multimodal_message_text_only_omits_file_fields():
event = MultimodalMessageClientToOrchestratorEvent(text="hello")
assert event.to_dict() == {
"type": "multimodal_message",
"text": {"type": "user_message", "text": "hello"},
}