模型

旗舰模型

文本转语音

语音转文本

语音智能体

音乐

模型概览

ElevenLabs API 提供多种音频模型，针对不同用例、质量等级和性能要求进行了优化。

已弃用模型

Eleven v4

Eleven v4 是我们先进的语音合成模型，提供最高质量的音频、丰富表现力，以及对音色演绎方式的精细控制。Eleven v4 支持高保真语音克隆，在长文本生成中也能可靠保留说话人特征。

该模型适合以下场景：

• 角色旁白配音：情感表现丰富，适合游戏和动画。
• 情感对话：生成自然逼真的对话，具备丰富情感表现和上下文理解能力。
• 有声书制作：适合需要复杂情感演绎的长篇旁白。
• 多语言项目：切换语言时仍保持一致的音色质量。

可通过 文本转对话 API 使用 Eleven v4。

支持的语言

Eleven v4 模型系列支持 90 多种语言，包括：

南非荷兰语（af）、阿拉伯语（ar）、亚美尼亚语（hy）、阿萨姆语（as）、阿斯图里亚斯语（ast）、阿塞拜疆语（az）、白俄罗斯语（be）、孟加拉语（bn）、波斯尼亚语（bs）、保加利亚语（bg）、缅甸语（my）、粤语（yue）、加泰罗尼亚语（ca）、宿务语（ceb）、克罗地亚语（hr）、捷克语（cs）、丹麦语（da）、荷兰语（nl）、英语（en）、爱沙尼亚语（et）、菲律宾语（fil）、芬兰语（fi）、法语（fr）、加利西亚语（gl）、格鲁吉亚语（ka）、德语（de）、希腊语（el）、古吉拉特语（gu）、豪萨语（ha）、希伯来语（he）、印地语（hi）、匈牙利语（hu）、冰岛语（is）、印度尼西亚语（id）、爱尔兰语（ga）、意大利语（it）、日语（ja）、爪哇语（jv）、卡纳达语（kn）、哈萨克语（kk）、韩语（ko）、吉尔吉斯语（ky）、拉脱维亚语（lv）、林加拉语（ln）、立陶宛语（lt）、卢森堡语（lb）、马其顿语（mk）、马来语（ms）、马拉雅拉姆语（ml）、马耳他语（mt）、普通话（zh）、毛利语（mi）、马拉地语（mr）、蒙古语（mn）、尼泊尔语（ne）、挪威语（no）、奥克语（oc）、奥里亚语（or）、普什图语（ps）、波斯语（fa）、波兰语（pl）、葡萄牙语（pt）、旁遮普语（pa）、罗马尼亚语（ro）、俄语（ru）、塞尔维亚语（sr）、信德语（sd）、斯洛伐克语（sk）、斯洛文尼亚语（sl）、索马里语（so）、西班牙语（es）、斯瓦希里语（sw）、瑞典语（sv）、塔吉克语（tg）、泰米尔语（ta）、泰卢固语（te）、泰语（th）、土耳其语（tr）、乌克兰语（uk）、乌尔都语（ur）、乌兹别克语（uz）、越南语（vi）、威尔士语（cy）、约鲁巴语（yo）。

Eleven v4 Turbo

Eleven v4 Turbo 是我们先进的实时语音合成模型，提供高质量音频、丰富表现力，以及对音色演绎方式的精细控制。Eleven v4 Turbo 支持高保真语音克隆，中位推理延迟约为 100ms。

该模型适合以下场景：

• 客服智能体：驱动可实时解决客户问题的语音智能体。
• AI 助手：生成自然逼真的对话，具备丰富情感表现和上下文理解能力。
• 互动角色：适合需要富有表现力角色的音频体验。

可通过 文本转对话 WebSocket 使用 Eleven v4 Turbo。

支持的语言

Eleven v4 模型系列支持 90 多种语言，包括：

南非荷兰语（af）、阿拉伯语（ar）、亚美尼亚语（hy）、阿萨姆语（as）、阿斯图里亚斯语（ast）、阿塞拜疆语（az）、白俄罗斯语（be）、孟加拉语（bn）、波斯尼亚语（bs）、保加利亚语（bg）、缅甸语（my）、粤语（yue）、加泰罗尼亚语（ca）、宿务语（ceb）、克罗地亚语（hr）、捷克语（cs）、丹麦语（da）、荷兰语（nl）、英语（en）、爱沙尼亚语（et）、菲律宾语（fil）、芬兰语（fi）、法语（fr）、加利西亚语（gl）、格鲁吉亚语（ka）、德语（de）、希腊语（el）、古吉拉特语（gu）、豪萨语（ha）、希伯来语（he）、印地语（hi）、匈牙利语（hu）、冰岛语（is）、印度尼西亚语（id）、爱尔兰语（ga）、意大利语（it）、日语（ja）、爪哇语（jv）、卡纳达语（kn）、哈萨克语（kk）、韩语（ko）、吉尔吉斯语（ky）、拉脱维亚语（lv）、林加拉语（ln）、立陶宛语（lt）、卢森堡语（lb）、马其顿语（mk）、马来语（ms）、马拉雅拉姆语（ml）、马耳他语（mt）、普通话（zh）、毛利语（mi）、马拉地语（mr）、蒙古语（mn）、尼泊尔语（ne）、挪威语（no）、奥克语（oc）、奥里亚语（or）、普什图语（ps）、波斯语（fa）、波兰语（pl）、葡萄牙语（pt）、旁遮普语（pa）、罗马尼亚语（ro）、俄语（ru）、塞尔维亚语（sr）、信德语（sd）、斯洛伐克语（sk）、斯洛文尼亚语（sl）、索马里语（so）、西班牙语（es）、斯瓦希里语（sw）、瑞典语（sv）、塔吉克语（tg）、泰米尔语（ta）、泰卢固语（te）、泰语（th）、土耳其语（tr）、乌克兰语（uk）、乌尔都语（ur）、乌兹别克语（uz）、越南语（vi）、威尔士语（cy）、约鲁巴语（yo）。

Eleven v3

Eleven v3 是我们的上一代语音合成模型，可在多种语言中生成自然逼真的语音，具备丰富情感表现和上下文理解能力。

Eleven v3 推出了新的文本转对话 API，可在多种语言中生成自然逼真的对话，具备丰富情感表现和上下文理解能力。也可通过文本转语音 API 使用 Eleven v3，在多种语言中生成自然逼真的语音，具备丰富情感表现和上下文理解能力。

在这里了解更多文本转对话 API 信息。

支持的语言

Eleven v3 模型支持 70 多种语言，包括：

南非荷兰语（af）、阿拉伯语（ar）、亚美尼亚语（hy）、阿萨姆语（as）、阿斯图里亚斯语（ast）、阿塞拜疆语（az）、白俄罗斯语（be）、孟加拉语（bn）、波斯尼亚语（bs）、保加利亚语（bg）、缅甸语（my）、粤语（yue）、加泰罗尼亚语（ca）、宿务语（ceb）、齐切瓦语（ny）、克罗地亚语（hr）、捷克语（cs）、丹麦语（da）、荷兰语（nl）、英语（en）、爱沙尼亚语（et）、菲律宾语（fil）、芬兰语（fi）、法语（fr）、加利西亚语（gl）、格鲁吉亚语（ka）、德语（de）、希腊语（el）、古吉拉特语（gu）、豪萨语（ha）、希伯来语（he）、印地语（hi）、匈牙利语（hu）、冰岛语（is）、印度尼西亚语（id）、爱尔兰语（ga）、意大利语（it）、日语（ja）、爪哇语（jv）、卡纳达语（kn）、哈萨克语（kk）、吉尔吉斯语（ky）、韩语（ko）、拉脱维亚语（lv）、林加拉语（ln）、立陶宛语（lt）、卢森堡语（lb）、马其顿语（mk）、马来语（ms）、马拉雅拉姆语（ml）、马耳他语（mt）、普通话（zh）、毛利语（mi）、马拉地语（mr）、蒙古语（mn）、尼泊尔语（ne）、挪威语（no）、奥克语（oc）、奥里亚语（or）、普什图语（ps）、波斯语（fa）、波兰语（pl）、葡萄牙语（pt）、旁遮普语（pa）、罗马尼亚语（ro）、俄语（ru）、塞尔维亚语（sr）、信德语（sd）、斯洛伐克语（sk）、斯洛文尼亚语（sl）、索马里语（so）、西班牙语（es）、斯瓦希里语（sw）、瑞典语（sv）、塔吉克语（tg）、泰米尔语（ta）、泰卢固语（te）、泰语（th）、土耳其语（tr）、乌克兰语（uk）、乌尔都语（ur）、乌兹别克语（uz）、越南语（vi）、威尔士语（cy）、约鲁巴语（yo）。

Eleven v3 Conversational

Eleven v3 Conversational 是我们的上一代实时语音合成模型。它可在多种语言中生成自然逼真的语音，具备丰富情感表现和上下文理解能力。

Eleven v3 Conversational 推出了新的文本转对话 WebSocket，可在多种语言中生成自然逼真的对话，具备丰富情感表现和上下文理解能力。

Eleven v3 Conversational 推出了新的文本转对话 WebSocket，可在多种语言中生成自然逼真的对话，具备丰富情感表现和上下文理解能力。

在这里了解更多文本转对话 WebSocket 信息。

支持的语言

Eleven v3 模型支持 70 多种语言，包括：

南非荷兰语（af）、阿拉伯语（ar）、亚美尼亚语（hy）、阿萨姆语（as）、阿斯图里亚斯语（ast）、阿塞拜疆语（az）、白俄罗斯语（be）、孟加拉语（bn）、波斯尼亚语（bs）、保加利亚语（bg）、缅甸语（my）、粤语（yue）、加泰罗尼亚语（ca）、宿务语（ceb）、齐切瓦语（ny）、克罗地亚语（hr）、捷克语（cs）、丹麦语（da）、荷兰语（nl）、英语（en）、爱沙尼亚语（et）、菲律宾语（fil）、芬兰语（fi）、法语（fr）、加利西亚语（gl）、格鲁吉亚语（ka）、德语（de）、希腊语（el）、古吉拉特语（gu）、豪萨语（ha）、希伯来语（he）、印地语（hi）、匈牙利语（hu）、冰岛语（is）、印度尼西亚语（id）、爱尔兰语（ga）、意大利语（it）、日语（ja）、爪哇语（jv）、卡纳达语（kn）、哈萨克语（kk）、吉尔吉斯语（ky）、韩语（ko）、拉脱维亚语（lv）、林加拉语（ln）、立陶宛语（lt）、卢森堡语（lb）、马其顿语（mk）、马来语（ms）、马拉雅拉姆语（ml）、马耳他语（mt）、普通话（zh）、毛利语（mi）、马拉地语（mr）、蒙古语（mn）、尼泊尔语（ne）、挪威语（no）、奥克语（oc）、奥里亚语（or）、普什图语（ps）、波斯语（fa）、波兰语（pl）、葡萄牙语（pt）、旁遮普语（pa）、罗马尼亚语（ro）、俄语（ru）、塞尔维亚语（sr）、信德语（sd）、斯洛伐克语（sk）、斯洛文尼亚语（sl）、索马里语（so）、西班牙语（es）、斯瓦希里语（sw）、瑞典语（sv）、塔吉克语（tg）、泰米尔语（ta）、泰卢固语（te）、泰语（th）、土耳其语（tr）、乌克兰语（uk）、乌尔都语（ur）、乌兹别克语（uz）、越南语（vi）、威尔士语（cy）、约鲁巴语（yo）。

Multilingual v2

Eleven Multilingual v2 是上一代具备情感感知能力的语音合成模型。它可在多种语言中生成自然逼真的语音，具备丰富情感表现和上下文理解能力。

该模型可在所有支持的语言中提供一致的音色质量和个性，同时保留说话人的独特特征与口音。

该模型尤其擅长需要高质量、细腻情感表达语音的场景：

• 角色旁白配音：情感表现丰富，适合游戏和动画。
• 专业内容：适合企业视频和在线学习材料。
• 多语言项目：切换语言时仍保持一致的音色质量。
• 稳定质量：生成稳定、高质量的音频输出。

虽然相比 Flash 模型，它的单字符延迟和成本更高，但对于重视逼真语音的项目，可提供更出色的质量。

多语言 v2 模型支持 29 种语言：

英语（美国、英国、澳大利亚、加拿大）、日语、中文、德语、印地语、法语（法国、加拿大）、韩语、葡萄牙语（巴西、葡萄牙）、意大利语、西班牙语（西班牙、墨西哥）、印尼语、荷兰语、土耳其语、菲律宾语、波兰语、瑞典语、保加利亚语、罗马尼亚语、阿拉伯语（沙特阿拉伯、阿联酋）、捷克语、希腊语、芬兰语、克罗地亚语、马来语、斯洛伐克语、丹麦语、泰米尔语、乌克兰语和俄语。

Flash v2.5

Eleven Flash v2.5 是我们最快的语音合成模型，专为实时应用和 Agents Platform 设计。它可在 32 种语言中提供高质量语音和超低延迟（约 75ms†）。

该模型兼顾速度与质量，适合交互式应用，同时在不同语言中保持自然的输出和一致的音色特征。

该模型尤其适合：

• Agents Platform：适合实时语音智能体和聊天机器人。
• 交互式应用：适合需要即时响应的游戏和应用。
• 大规模处理：可高效进行批量文本转语音转换。

Flash v2.5 的 API 生成价格更低，延迟仅 75ms，是需要快速、可靠地进行多语言语音合成的高性价比选择。

Flash v2.5 支持 32 种语言——包括 v2 模型支持的所有语言，以及：

匈牙利语、挪威语和越南语

注意事项

模型选择指南

如需了解最适合需求和使用场景的模型，请参阅模型选择指南。

字符限制

单次文本转语音请求支持的最大字符数因模型而异。

Scribe v2

Scribe v2 是我们先进的语音识别模型，专为 90 多种语言的精准转录设计。它提供精确到词级的时间戳，以及说话人分离和动态音频标记等高级功能。

该模型擅长需要精准语音转文本的场景：

• 转录服务：适合将音频或视频内容转换为文本
• 会议记录：适合捕捉和记录对话内容
• 内容分析：适合处理和分析音频内容
• 多语言识别：支持 90 多种语言的精准转录

主要功能：

• 提供词级时间戳的精准转录
• 支持多说话人音频的说话人分离
• 动态音频标记，提供更丰富的上下文
• 支持 90 多种语言
• 实体检测
• 关键词提示
• 转录文本编辑

在这里了解更多 Scribe v2 信息。

Scribe v2 Realtime

Scribe v2 Realtime 是我们最快、最精准的实时语音识别模型，以超低 150ms 延迟，在 90 多种语言中提供先进的识别准确率。

该模型擅长对话场景：

• 实时会议转录：适合实时转录
• AI 智能体：适合实时对话
• 多语言识别：支持自动语言识别，可精准转录 90 多种语言

主要功能：

• 超低延迟：约 150 毫秒即可获得部分转录结果
• 流式支持：可分块发送音频，同时实时接收转录文本
• 多种音频格式：支持 PCM（8kHz 至 48kHz）和 μ-law 编码
• 语音活动检测（VAD）：基于静音检测自动分割语音
• 手动提交控制：可完全控制何时完成转录片段
• 实体检测
• 转录文本编辑

在这里了解更多 Scribe v2 Realtime 信息。

Scribe v2 Medical

Scribe v2 Medical 是专用于医疗和临床音频的批量语音识别模型。它是 Scribe v2 的微调版本，可提升对药品名称、解剖学、病理学和临床口述内容的识别，同时保持 Scribe v2 对日常语音的准确率。它与 Scribe v2 使用相同的语音转文本 API，计费标准也相同。将 scribe_v2_medical 作为 model_id 传入。

该模型适合：

• 临床文档记录：对话中出现医疗术语的环境式诊疗和记录
• 口述：包含大量药物、剂量和检查结果的内容
• 接诊和协调通话：患者描述自身状况的场景，通常通过电话进行
• 合规工作流程：结合实体检测识别 PHI 类别

主要功能：

• 与 Scribe v2 使用相同的请求结构（keyterms、entity_detection、no_verbatim、说话人分离、时间戳）
• 改进对药品名称、解剖学和病理学术语的识别
• 相比 Scribe v2，日常语音识别无性能回退
• 支持 90 多种语言
• 支持多说话人音频的说话人分离
• 动态音频标记
• 实体检测，包括 PHI 类别

Scribe v2 Medical 是批量模型。如需实时转录，请使用 Scribe v2 Realtime。

Scribe v2 Medical 符合 HIPAA 要求，企业版客户可签署商业伙伴协议，并使用零保留模式（ZRM）。启用 ZRM 后，每个请求完成后会立即删除音频输入和文本输出。ElevenLabs 不会保留任何内容，应用将收到完整的 API 响应，并可在自己的控制下保留转录文本。

在这里了解更多语音转文本信息。

Eleven Realtime

Eleven Realtime 是一类新型语音转语音模型，用于构建自然的语音智能体。每个 Realtime 模型都是一个完整的语音智能体：语音识别、语音活动检测与轮次管理、LLM 和文本转语音，均由 ElevenLabs 选择并调优，使其作为一个系统协同工作。选择一个 Realtime 模型，即可通过一次选择获得性能优异的智能体，无需配置任何组件。

现有两种 Realtime 模型。

Eleven Realtime v1 Mini 针对快速、自然的对话进行了优化，适合以下场景：

• AI 助手：适合以对话本身为核心产品的快速、富有表现力的对话。
• 教育辅导：自然的来回交流，可跟上学习者的节奏。
• 互动角色：适合游戏和娱乐的富有表现力的角色。

Eleven Realtime v1 Max 针对复杂任务进行了优化，适合以下场景：

• 客户支持：解决需要遵循流程和查找信息的问题。
• 潜在客户资格评估：收集信息并决定下一步行动的结构化对话。
• 多步骤工作流程：调用工具来查找信息或执行操作的任务。

主要功能：

• 通过一个模型选择即可获得语音识别、轮次管理、语言模型和音色
• 自然的轮次管理和打断处理
• 工具调用
• 可使用 ElevenLabs 声音库中的自定义音色
• 支持 90 多种语言
• 通过模型选择即可在 v1 Mini 和 v1 Max 之间切换，无需更改集成

Eleven Realtime 可在 ElevenAgents 中使用：从模型下拉菜单选择 Realtime 模型即可。也可通过 Realtime API 使用，该 API 通过 WebSocket 与 OpenAI 的 Realtime API 兼容。如果已在使用 OpenAI 的 Realtime API，请参阅迁移指南。

支持的语言

Realtime 模型支持 90 多种语言。请参阅 Eleven v4 语言列表。

在这里了解更多 Eleven Realtime 信息。

Eleven Music

Eleven Music 是我们的录音棚级音乐生成模型。你可以使用自然语言提示词生成任意风格的音乐。

该模型非常适合以下场景：

• 游戏原声：为游戏创作沉浸式配乐
• 播客背景音乐：用专业音乐提升播客效果
• 营销：为广告短片添加背景音乐

主要功能：

• 完全控制流派、风格和结构
• 可生成带人声或纯器乐音乐
• 支持多种语言，包括英语、西班牙语、德语、日语等
• 可编辑单个片段或整首歌曲的声音和歌词

在这里了解更多 Eleven Music 信息。

并发与优先级

订阅套餐决定可同时处理的请求数量，以及请求在队列中的优先级。 语音转文本的并发上限更高。 达到并发上限后，后续请求会与优先级较低的请求一同排队处理。 实际通常只会增加约 50ms 的延迟。

响应标头包含 current-concurrent-requests 和 maximum-concurrent-requests，可用于监控并发情况。

每分钟 API 请求数与并发请求数

请务必了解，每分钟 API 请求数与并发请求数是不同的指标，具体取决于使用模式。

每分钟 API 请求数可能与并发请求数不同，因为它取决于每个请求的耗时以及请求的批处理方式。

示例 1：间隔发送请求 如果每分钟有 180 个请求，每个请求需 1 秒完成，并且每隔 0.33 秒发送一个请求，那么最大并发请求数为 3，平均值也为 3，因为始终会有 3 个请求在处理中。

示例 2：批量发送请求 不过，如果使用模式不同，例如每分钟有 180 个请求，每个请求需 3 秒完成，但全部同时发出，那么最大并发请求数为 180，平均值为 9（该分钟的前 3 秒同时有 180 个请求，后 57 秒则有 0 个请求）。

系统关注的是并发数，因此相比每分钟请求数，每个请求的耗时和发送模式更重要。

端点请求方式会影响并发上限：

• 使用 HTTP 时，每个请求都会单独计入并发上限。
• 使用文本转语音 WebSocket 时，只有模型生成音频的时间会计入并发上限。这意味着大多数时候，已打开的 websocket 完全不会计入并发上限。
• 文本转对话 WebSocket 的工作方式不同：每个打开的连接都会从独立池中预留一个对话会话，直到连接关闭；通过该连接生成的音频不计入标准并发上限。这样更容易理解，因为一个连接就是一个会话，并且对话会话上限已调整以适应这种新的并发计算方式。请参阅文本转对话并发。

了解并发上限

套餐对应的并发上限不应理解为可同时处理的对话、电话、角色旁白配音等的最大数量。 实际数量取决于多项因素，包括所使用的具体 AI 语音以及使用场景的特征。

一般来说，并发上限为 5 通常可支持约 100 路同时音频播报。

这是因为音频生成速度与 TTS 请求处理时间存在差异。 下图展示了如何在仅达到 2 个并发请求的情况下，支持与不同用户进行的 4 通并发通话。

如果在任何时候超出套餐的并发上限，且使用的是企业版套餐，模型请求仍可能根据可用容量以尽力而为的方式成功处理，但速度会较慢。

文本转对话并发

根据调用 API 的方式，文本转对话请求会以两种不同方式计量：

• HTTP 端点（创建对话 和流式对话）会在生成音频期间计入套餐的标准并发上限，与其他任何文本转语音请求相同。
• WebSocket 端点，例如文本转对话 WebSocket，会按对话会话计量。无论当前是否正在生成音频，打开的连接在保持打开期间都会占用一个对话会话。

基于会话的计量让容量规划更简单：一个连接就是一个会话，因此使用量不会随生成活动而波动。由于会话在整个连接期间占用，而非仅在生成音频时占用，因此对话会话上限已调整以适应这种新的并发计算方式。

如果在工作区的所有对话会话均被占用时打开连接，新连接会被拒绝并返回 too_many_concurrent_requests 错误。若要释放会话，请关闭不再需要的连接；除非发送 keep_alive 消息，否则连接在闲置 20 秒后也会自动关闭。

要监控对话会话，请在控制台侧边栏底部打开开发者，选择分析标签页，并在用量视图中查看并发请求数指标。对话会话会以独立序列 TTD Websocket Sessions 报告，与其他并发请求分开显示。

扩展测试并发上限

扩展测试有助于发现客户端扩展问题，并验证是否已针对使用场景正确设置并发上限。

强烈建议尽可能贴近实际使用情况测试端到端 workflow。建议通过模拟并测量可支持的用户数量来实现这一点。请注意：

• 模拟用户，而非原始请求
• 模拟典型用户行为，例如在发出请求前等待音频播放、用户说话或转录完成
• 在数分钟内逐步缓慢增加用户数量
• 为请求时机和请求大小引入随机性
• 记录延迟指标以及 API 返回的所有错误代码

例如，要测试一个设计为支持 100 路同时对话的智能体系统，可以创建最多 100 个独立的“用户”，每个用户模拟一段对话。对话通常由重复循环组成：用户说话约 10 秒，随后调用 TTS API 生成约 150 个字符，再向用户播放音频约 10 秒。因此，每个用户应每 20 秒通过 websocket 发起一次文本转语音 API 调用，请求 150 个字符的文本，并对等待时间和请求字符数加入少量随机性。测试应以每秒创建一个用户的速度进行，直到达到 100 个用户，然后总共测试 10 分钟，以验证整体稳定性。

import json
import random
import time
import gevent
import locust
from locust import User, task, events, constant_throughput
import websocket
# Averages up to 10 seconds of audio when played, depends on the voice speed
DEFAULT_TEXT = (
    "Hello, this is a test message. I am testing if a long input will cause issues for the model "
    "like this sentence. "
)
TEXT_ARRAY = [
    "Hello.",
    "Hello, this is a test message.",
    DEFAULT_TEXT,
    DEFAULT_TEXT * 2,
    DEFAULT_TEXT * 3
]
# Custom command line arguments
@events.init_command_line_parser.add_listener
def on_parser_init(parser):
    parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication")
    parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding")
    parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use")
    parser.add_argument("--use-text-array", default="false", help="Text to use")
    parser.add_argument("--voice-id", default="aria", help="Text to use")
class WebSocketTTSUser(User):
    # Each user will send a request every 20 seconds, regardless of how long each request takes
    wait_time = constant_throughput(0.05)
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.api_key = self.environment.parsed_options.api_key
        self.voice_id = self.environment.parsed_options.voice_id
        self.text = self.environment.parsed_options.text
        self.encoding = self.environment.parsed_options.encoding
        self.use_text_array = self.environment.parsed_options.use_text_array
        if self.use_text_array:
            self.text = random.choice(TEXT_ARRAY)
        self.all_recieved = False
    @task
    def tts_task(self):
        # Do jitter waiting of up to 1 second
        # Users appear to be spawned every second so this ensures requests are not aligned
        gevent.sleep(random.random())
        max_wait_time = 10
        # Connection details
        uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}"
        headers = {"xi-api-key": self.api_key}
        ws = None
        self.all_recieved = False
        try:
            init_msg = {"text": " "}
            # Use proper header format for websocket - this is case sensitive!
            ws = websocket.create_connection(uri, header=headers)
            ws.send(json.dumps(init_msg))
            # Start measuring after websocket initiated but before any messages are sent
            send_request_time = time.perf_counter()
            ws.send(json.dumps({"text": self.text}))
            # Send to flush and receive the audio
            ws.send(json.dumps({"text": ""}))
            def _receive():
                t_first_response = None
                audio_size = 0
                try:
                    while True:
                        # Wait up to 10 seconds for a response
                        ws.settimeout(max_wait_time)
                        response = ws.recv()
                        response_data = json.loads(response)
                        if "audio" in response_data and response_data["audio"]:
                            audio_size = audio_size + len(response_data["audio"])
                        if t_first_response is None:
                            t_first_response = time.perf_counter()
                            first_byte_ms = (
                                t_first_response - send_request_time
                            ) * 1000
                            if audio_size is None:
                                # The first response should always have audio
                                locust.events.request.fire(
                                    request_type="websocket",
                                    name="Bad Response (no audio)",
                                    response_time=first_byte_ms,
                                    response_length=audio_size,
                                    exception=Exception("Response has no audio"),
                                )
                                break
                        if "isFinal" in response_data and response_data["isFinal"]:
                            # Fire this event once finished streaming, but report the important TTFB metric
                            locust.events.request.fire(
                                request_type="websocket",
                                name="TTS Stream Success (First Byte)",
                                response_time=first_byte_ms,
                                response_length=audio_size,
                                exception=None,
                            )
                            break
                except websocket.WebSocketTimeoutException:
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Timeout",
                        response_time=max_wait_time * 1000,
                        response_length=audio_size,
                        exception=Exception("Timeout waiting for response"),
                    )
                except Exception as e:
                    # Typically JSON decode error if the server returns HTTP backoff error
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Failure",
                        response_time=0,
                        response_length=0,
                        exception=e,
                    )
                finally:
                    self.all_recieved = True
            gevent.spawn(_receive)
            # Sleep until recieved so new tasks aren't spawned
            while not self.all_recieved:
                gevent.sleep(1)
        except websocket.WebSocketTimeoutException:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Timeout",
                response_time=max_wait_time * 1000,
                response_length=0,
                exception=Exception("Timeout waiting for response"),
            )
        except Exception as e:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Failure",
                response_time=0,
                response_length=0,
                exception=e,
            )
        finally:
            # Try and close the websocket gracefully
            try:
                if ws:
                    ws.close()
            except Exception:
                pass