Alibaba Cloud Model Studio:Síntese de fala em tempo real

Instruções

1. Leia o conteúdo em inglês para compreender O QUE precisa ser comunicado

2. Escreva o texto em português do Brasil DO ZERO — esqueça a estrutura das frases em inglês

3. Preserve toda a formatação markdown, blocos de código, links e imagens exatamente como estão

4. Tags xref (<a data-tag="xref" ...>texto</a>) — preserve a tag INTEIRA com todos os atributos na ordem e caixa originais, traduza APENAS o texto visível entre > e

5. Aplique todas as regras específicas do idioma rigorosamente

6. Aplique as regras de stopwords com tolerância zero

7. Use o modo imperativo em passos numerados e listas de procedimentos

8. Garanta a consistência terminológica — o mesmo termo deve ter a mesma tradução em todo o documento

9. Varie os inícios de frase em listas e tabelas — nenhum início deve se repetir 3 ou mais vezes

10. Retorne APENAS o documento markdown em português do Brasil, sem explicações

Qwen-Audio-TTS/CosyVoice

O Qwen-Audio-TTS e o Qwen-Audio-TTS/CosyVoice compartilham o mesmo protocolo WebSocket. Os exemplos a seguir utilizam qwen-audio-3.0-tts-flash. Para usar o Qwen-Audio-TTS/CosyVoice, substitua o parâmetro model por um modelo do Qwen-Audio-TTS/CosyVoice (como cosyvoice-v3-flash) e defina o parâmetro voice com a voz desejada.

Instruções

1. Leia o conteúdo em inglês para compreender O QUE precisa ser comunicado

2. Escreva o texto em português do Brasil DO ZERO — esqueça a estrutura das frases em inglês

3. Preserve toda a formatação markdown, blocos de código, links e imagens exatamente como estão

4. Tags xref (<a data-tag="xref" ...>texto</a>) — preserve A TAG INTEIRA com todos os atributos na ordem e capitalização originais, traduza APENAS o texto visível entre > e

5. Aplique todas as regras específicas do idioma rigorosamente

6. Aplique as regras de stopwords com tolerância zero

7. Use o modo imperativo em passos numerados e listas de procedimentos

8. Garanta a consistência terminológica — o mesmo termo deve ter a mesma tradução em todo o documento

9. Varie os inícios de frase em listas e tabelas — nenhum início deve se repetir 3 ou mais vezes

10. Retorne APENAS o documento markdown em português do Brasil, sem explicações

    Go

    package main
    
    import (
    	"encoding/json"
    	"fmt"
    	"net/http"
    	"os"
    	"strings"
    	"time"
    
    	"github.com/google/uuid"
    	"github.com/gorilla/websocket"
    )
    
    const (
    	// The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
    	wsURL      = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/"
    	outputFile = "output.mp3"
    )
    
    func main() {
    	// The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    	// If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: apiKey := "sk-xxx"
    	apiKey := os.Getenv("DASHSCOPE_API_KEY")
    
    	// Clear the output file
    	os.Remove(outputFile)
    	os.Create(outputFile)
    
    	// Connect to WebSocket
    	header := make(http.Header)
    	header.Add("X-DashScope-DataInspection", "enable")
    	header.Add("Authorization", fmt.Sprintf("bearer %s", apiKey))
    
    	conn, resp, err := websocket.DefaultDialer.Dial(wsURL, header)
    	if err != nil {
    		if resp != nil {
    			fmt.Printf("Connection failed, HTTP status code: %d\n", resp.StatusCode)
    		}
    		fmt.Println("Connection failed:", err)
    		return
    	}
    	defer conn.Close()
    
    	// Generate task ID
    	taskID := uuid.New().String()
    	fmt.Printf("Generated task ID: %s\n", taskID)
    
    	// Sending run-task event
    	runTaskCmd := map[string]interface{}{
    		"header": map[string]interface{}{
    			"action":    "run-task",
    			"task_id":   taskID,
    			"streaming": "duplex",
    		},
    		"payload": map[string]interface{}{
    			"task_group": "audio",
    			"task":       "tts",
    			"function":   "SpeechSynthesizer",
    			"model":      "qwen-audio-3.0-tts-flash",
    			"parameters": map[string]interface{}{
    				"text_type":   "PlainText",
    				"voice":       "longanlingxi",
    				"format":      "mp3",
    				"sample_rate": 22050,
    				"volume":      50,
    				"rate":        1,
    				"pitch":       1,
    				// If enable_ssml is set to true, only one continue-task event can be sent; otherwise the error "Text request limit violated, expected 1." will be returned
    				"enable_ssml": false,
    			},
    			"input": map[string]interface{}{},
    		},
    	}
    
    	runTaskJSON, _ := json.Marshal(runTaskCmd)
    	fmt.Printf("Sending run-task event: %s\n", string(runTaskJSON))
    
    	err = conn.WriteMessage(websocket.TextMessage, runTaskJSON)
    	if err != nil {
    		fmt.Println("Failed to send run-task:", err)
    		return
    	}
    
    	textSent := false
    
    	// Process messages
    	for {
    		messageType, message, err := conn.ReadMessage()
    		if err != nil {
    			fmt.Println("Failed to read message:", err)
    			break
    		}
    
    		// Process binary message
    		if messageType == websocket.BinaryMessage {
    			fmt.Printf("Received binary message, length: %d\n", len(message))
    			file, _ := os.OpenFile(outputFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
    			file.Write(message)
    			file.Close()
    			continue
    		}
    
    		// Process text message
    		messageStr := string(message)
    		fmt.Printf("Received text message: %s\n", strings.ReplaceAll(messageStr, "\n", ""))
    
    		// Parse JSON to get event type
    		var msgMap map[string]interface{}
    		if json.Unmarshal(message, &msgMap) == nil {
    			if header, ok := msgMap["header"].(map[string]interface{}); ok {
    				if event, ok := header["event"].(string); ok {
    					fmt.Printf("Event type: %s\n", event)
    
    					switch event {
    					case "task-started":
    						fmt.Println("=== Received task-started event ===")
    
    						if !textSent {
    							// Sending continue-task event
    
    							texts := []string{"Before my bed, moonlight shines bright, I suspect it's frost upon the ground.", "I raise my eyes to gaze at the bright moon, then bow my head, thinking of home."}
    
    							for _, text := range texts {
    								continueTaskCmd := map[string]interface{}{
    									"header": map[string]interface{}{
    										"action":    "continue-task",
    										"task_id":   taskID,
    										"streaming": "duplex",
    									},
    									"payload": map[string]interface{}{
    										"input": map[string]interface{}{
    											"text": text,
    										},
    									},
    								}
    
    								continueTaskJSON, _ := json.Marshal(continueTaskCmd)
    								fmt.Printf("Sending continue-task event: %s\n", string(continueTaskJSON))
    
    								err = conn.WriteMessage(websocket.TextMessage, continueTaskJSON)
    								if err != nil {
    									fmt.Println("Failed to send continue-task:", err)
    									return
    								}
    							}
    
    							textSent = true
    
    							// Delay before sending finish-task
    							time.Sleep(500 * time.Millisecond)
    
    							// Sending finish-task event
    							finishTaskCmd := map[string]interface{}{
    								"header": map[string]interface{}{
    									"action":    "finish-task",
    									"task_id":   taskID,
    									"streaming": "duplex",
    								},
    								"payload": map[string]interface{}{
    									"input": map[string]interface{}{},
    								},
    							}
    
    							finishTaskJSON, _ := json.Marshal(finishTaskCmd)
    							fmt.Printf("Sending finish-task event: %s\n", string(finishTaskJSON))
    
    							err = conn.WriteMessage(websocket.TextMessage, finishTaskJSON)
    							if err != nil {
    								fmt.Println("Failed to send finish-task:", err)
    								return
    							}
    						}
    
    					case "task-finished":
    						fmt.Println("=== Task completed ===")
    						return
    
    					case "task-failed":
    						fmt.Println("=== Task failed ===")
    						if header["error_message"] != nil {
    							fmt.Printf("Error message: %s\n", header["error_message"])
    						}
    						return
    
    					case "result-generated":
    						fmt.Println("Received result-generated event")
    					}
    				}
    			}
    		}
    	}
    }

    C#

    using System.Net.WebSockets;
    using System.Text;
    using System.Text.Json;
    
    class Program {
        // The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
        // If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: private static readonly string ApiKey = "sk-xxx"
        private static readonly string ApiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY") ?? throw new InvalidOperationException("DASHSCOPE_API_KEY environment variable is not set.");
    
        // The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        private const string WebSocketUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/";
        // Output file path
        private const string OutputFilePath = "output.mp3";
    
        // WebSocket client
        private static ClientWebSocket _webSocket = new ClientWebSocket();
        // Cancellation token source
        private static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
        // Task ID
        private static string? _taskId;
        // Whether the task has started
        private static TaskCompletionSource<bool> _taskStartedTcs = new TaskCompletionSource<bool>();
    
        static async Task Main(string[] args) {
            try {
                // Clear the output file
                ClearOutputFile(OutputFilePath);
    
                // Connect to the WebSocket service
                await ConnectToWebSocketAsync(WebSocketUrl);
    
                // Start the message receiving task
                Task receiveTask = ReceiveMessagesAsync();
    
                // Send the run-task event
                _taskId = GenerateTaskId();
                await SendRunTaskCommandAsync(_taskId);
    
                // Wait for the task-started event
                await _taskStartedTcs.Task;
    
                // Send continue-task events
                string[] texts = {
                    "Before my bed, moonlight shines bright,",
                    "I suspect it\'s frost upon the ground.",
                    "I raise my eyes to gaze at the bright moon,",
                    "then bow my head, thinking of home."
                };
                foreach (string text in texts) {
                    await SendContinueTaskCommandAsync(text);
                }
    
                // Send the finish-task event
                await SendFinishTaskCommandAsync(_taskId);
    
                // Wait for the receiving task to complete
                await receiveTask;
    
                Console.WriteLine("Task completed, connection closed.");
            } catch (OperationCanceledException) {
                Console.WriteLine("Task cancelled.");
            } catch (Exception ex) {
                Console.WriteLine($"Error occurred: {ex.Message}");
            } finally {
                _cancellationTokenSource.Cancel();
                _webSocket.Dispose();
            }
        }
    
        private static void ClearOutputFile(string filePath) {
            if (File.Exists(filePath)) {
                File.WriteAllText(filePath, string.Empty);
                Console.WriteLine("Output file cleared.");
            } else {
                Console.WriteLine("Output file does not exist, no need to clear.");
            }
        }
    
        private static async Task ConnectToWebSocketAsync(string url) {
            var uri = new Uri(url);
            if (_webSocket.State == WebSocketState.Connecting || _webSocket.State == WebSocketState.Open) {
                return;
            }
    
            // Set the WebSocket connection headers
            _webSocket.Options.SetRequestHeader("Authorization", $"bearer {ApiKey}");
            _webSocket.Options.SetRequestHeader("X-DashScope-DataInspection", "enable");
    
            try {
                await _webSocket.ConnectAsync(uri, _cancellationTokenSource.Token);
                Console.WriteLine("Successfully connected to the WebSocket service.");
            } catch (OperationCanceledException) {
                Console.WriteLine("WebSocket connection cancelled.");
            } catch (Exception ex) {
                Console.WriteLine($"WebSocket connection failed: {ex.Message}");
                throw;
            }
        }
    
        private static async Task SendRunTaskCommandAsync(string taskId) {
            var command = CreateCommand("run-task", taskId, "duplex", new {
                task_group = "audio",
                task = "tts",
                function = "SpeechSynthesizer",
                model = "qwen-audio-3.0-tts-flash",
                parameters = new
                {
                    text_type = "PlainText",
                    voice = "longanlingxi",
                    format = "mp3",
                    sample_rate = 22050,
                    volume = 50,
                    rate = 1,
                    pitch = 1,
                    // If enable_ssml is set to true, only one continue-task event can be sent; otherwise the error "Text request limit violated, expected 1." will be returned
                    enable_ssml = false
                },
                input = new { }
            });
    
            await SendJsonMessageAsync(command);
            Console.WriteLine("run-task event sent.");
        }
    
        private static async Task SendContinueTaskCommandAsync(string text) {
            if (_taskId == null) {
                throw new InvalidOperationException("Task ID not initialized.");
            }
    
            var command = CreateCommand("continue-task", _taskId, "duplex", new {
                input = new {
                    text
                }
            });
    
            await SendJsonMessageAsync(command);
            Console.WriteLine("continue-task event sent.");
        }
    
        private static async Task SendFinishTaskCommandAsync(string taskId) {
            var command = CreateCommand("finish-task", taskId, "duplex", new {
                input = new { }
            });
    
            await SendJsonMessageAsync(command);
            Console.WriteLine("finish-task event sent.");
        }
    
        private static async Task SendJsonMessageAsync(string message) {
            var buffer = Encoding.UTF8.GetBytes(message);
            try {
                await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
            } catch (OperationCanceledException) {
                Console.WriteLine("Message sending cancelled.");
            }
        }
    
        private static async Task ReceiveMessagesAsync() {
            while (_webSocket.State == WebSocketState.Open) {
                var response = await ReceiveMessageAsync();
                if (response != null) {
                    var eventStr = response.RootElement.GetProperty("header").GetProperty("event").GetString();
                    switch (eventStr) {
                        case "task-started":
                            Console.WriteLine("Task started.");
                            _taskStartedTcs.TrySetResult(true);
                            break;
                        case "task-finished":
                            Console.WriteLine("Task completed.");
                            _cancellationTokenSource.Cancel();
                            break;
                        case "task-failed":
                            Console.WriteLine("Task failed: " + response.RootElement.GetProperty("header").GetProperty("error_message").GetString());
                            _cancellationTokenSource.Cancel();
                            break;
                        default:
                            // result-generated can be handled here
                            break;
                    }
                }
            }
        }
    
        private static async Task<JsonDocument?> ReceiveMessageAsync() {
            var buffer = new byte[1024 * 4];
            var segment = new ArraySegment<byte>(buffer);
    
            try {
                WebSocketReceiveResult result = await _webSocket.ReceiveAsync(segment, _cancellationTokenSource.Token);
    
                if (result.MessageType == WebSocketMessageType.Close) {
                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", _cancellationTokenSource.Token);
                    return null;
                }
    
                if (result.MessageType == WebSocketMessageType.Binary) {
                    // Process binary data
                    Console.WriteLine("Received binary data...");
    
                    // Save the binary data to file
                    using (var fileStream = new FileStream(OutputFilePath, FileMode.Append)) {
                        fileStream.Write(buffer, 0, result.Count);
                    }
    
                    return null;
                }
    
                string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                return JsonDocument.Parse(message);
            } catch (OperationCanceledException) {
                Console.WriteLine("Message receiving cancelled.");
                return null;
            }
        }
    
        private static string GenerateTaskId() {
            return Guid.NewGuid().ToString("N").Substring(0, 32);
        }
    
        private static string CreateCommand(string action, string taskId, string streaming, object payload) {
            var command = new {
                header = new {
                    action,
                    task_id = taskId,
                    streaming
                },
                payload
            };
    
            return JsonSerializer.Serialize(command);
        }
    }

    PHP

    Estrutura de diretórios do código de exemplo:

    my-php-project/

    ├── composer.json

    ├── vendor/

    └── index.php

    Conteúdo do arquivo composer.json (ajuste as versões das dependências conforme necessário):

    {
        "require": {
            "react/event-loop": "^1.3",
            "react/socket": "^1.11",
            "react/stream": "^1.2",
            "react/http": "^1.1",
            "ratchet/pawl": "^0.4"
        },
        "autoload": {
            "psr-4": {
                "App\\": "src/"
            }
        }
    }

    Conteúdo do arquivo index.php:

    <?php
    
    require __DIR__ . '/vendor/autoload.php';
    
    use Ratchet\Client\Connector;
    use React\EventLoop\Loop;
    use React\Socket\Connector as SocketConnector;
    
    // The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: $api_key = "sk-xxx"
    $api_key = getenv("DASHSCOPE_API_KEY");
    // The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
    $websocket_url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/'; // WebSocket server URL
    $output_file = 'output.mp3'; // Output file path
    
    $loop = Loop::get();
    
    if (file_exists($output_file)) {
        // Clear file content
        file_put_contents($output_file, '');
    }
    
    // Create a custom connector
    $socketConnector = new SocketConnector($loop, [
        'tcp' => [
            'bindto' => '0.0.0.0:0',
        ],
        'tls' => [
            'verify_peer' => false,
            'verify_peer_name' => false,
        ],
    ]);
    
    $connector = new Connector($loop, $socketConnector);
    
    $headers = [
        'Authorization' => 'bearer ' . $api_key,
        'X-DashScope-DataInspection' => 'enable'
    ];
    
    $connector($websocket_url, [], $headers)->then(function ($conn) use ($loop, $output_file) {
        echo "Connected to the WebSocket server\n";
    
        // Generate task ID
        $taskId = generateTaskId();
    
        // Send the run-task event
        sendRunTaskMessage($conn, $taskId);
    
        // Define the function to send continue-task events
        $sendContinueTask = function() use ($conn, $loop, $taskId) {
            // Text to be sent
            $texts = ["Before my bed, moonlight shines bright,", "I suspect it\'s frost upon the ground.", "I raise my eyes to gaze at the bright moon,", "then bow my head, thinking of home."];
            $continueTaskCount = 0;
            foreach ($texts as $text) {
                $continueTaskMessage = json_encode([
                    "header" => [
                        "action" => "continue-task",
                        "task_id" => $taskId,
                        "streaming" => "duplex"
                    ],
                    "payload" => [
                        "input" => [
                            "text" => $text
                        ]
                    ]
                ]);
                echo "Sending continue-task event: " . $continueTaskMessage . "\n";
                $conn->send($continueTaskMessage);
                $continueTaskCount++;
            }
            echo "Number of continue-task events sent: " . $continueTaskCount . "\n";
    
            // Send the finish-task event
            sendFinishTaskMessage($conn, $taskId);
        };
    
        // Flag for whether the task-started event was received
        $taskStarted = false;
    
        // Listen for messages
        $conn->on('message', function($msg) use ($conn, $sendContinueTask, $loop, &$taskStarted, $taskId, $output_file) {
            if ($msg->isBinary()) {
                // Write binary data to local file
                file_put_contents($output_file, $msg->getPayload(), FILE_APPEND);
            } else {
                // Process non-binary message
                $response = json_decode($msg, true);
    
                if (isset($response['header']['event'])) {
                    handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, $taskStarted);
                } else {
                    echo "Unknown message format\n";
                }
            }
        });
    
        // Listen for connection close
        $conn->on('close', function($code = null, $reason = null) {
            echo "Connection closed\n";
            if ($code !== null) {
                echo "Close code: " . $code . "\n";
            }
            if ($reason !== null) {
                echo "Close reason: " . $reason . "\n";
            }
        });
    }, function ($e) {
        echo "Unable to connect: {$e->getMessage()}\n";
    });
    
    $loop->run();
    
    /**
     * Generate task ID
     * @return string
     */
    function generateTaskId(): string {
        return bin2hex(random_bytes(16));
    }
    
    /**
     * Send the run-task event
     * @param $conn
     * @param $taskId
     */
    function sendRunTaskMessage($conn, $taskId) {
        $runTaskMessage = json_encode([
            "header" => [
                "action" => "run-task",
                "task_id" => $taskId,
                "streaming" => "duplex"
            ],
            "payload" => [
                "task_group" => "audio",
                "task" => "tts",
                "function" => "SpeechSynthesizer",
                "model" => "qwen-audio-3.0-tts-flash",
                "parameters" => [
                    "text_type" => "PlainText",
                    "voice" => "longanlingxi",
                    "format" => "mp3",
                    "sample_rate" => 22050,
                    "volume" => 50,
                    "rate" => 1,
                    "pitch" => 1,
                    // If enable_ssml is set to true, only one continue-task event can be sent; otherwise the error "Text request limit violated, expected 1." will be returned
                    "enable_ssml" => false
                ],
                "input" => (object) []
            ]
        ]);
        echo "Sending run-task event: " . $runTaskMessage . "\n";
        $conn->send($runTaskMessage);
        echo "run-task event sent\n";
    }
    
    /**
     * Read audio file
     * @param string $filePath
     * @return bool|string
     */
    function readAudioFile(string $filePath) {
        $voiceData = file_get_contents($filePath);
        if ($voiceData === false) {
            echo "Unable to read audio file\n";
        }
        return $voiceData;
    }
    
    /**
     * Split audio data
     * @param string $data
     * @param int $chunkSize
     * @return array
     */
    function splitAudioData(string $data, int $chunkSize): array {
        return str_split($data, $chunkSize);
    }
    
    /**
     * Send the finish-task event
     * @param $conn
     * @param $taskId
     */
    function sendFinishTaskMessage($conn, $taskId) {
        $finishTaskMessage = json_encode([
            "header" => [
                "action" => "finish-task",
                "task_id" => $taskId,
                "streaming" => "duplex"
            ],
            "payload" => [
                "input" => (object) []
            ]
        ]);
        echo "Sending finish-task event: " . $finishTaskMessage . "\n";
        $conn->send($finishTaskMessage);
        echo "finish-task event sent\n";
    }
    
    /**
     * Handle events
     * @param $conn
     * @param $response
     * @param $sendContinueTask
     * @param $loop
     * @param $taskId
     * @param $taskStarted
     */
    function handleEvent($conn, $response, $sendContinueTask, $loop, $taskId, &$taskStarted) {
        switch ($response['header']['event']) {
            case 'task-started':
                echo "Task started, sending continue-task events...\n";
                $taskStarted = true;
                // Send continue-task events
                $sendContinueTask();
                break;
            case 'result-generated':
                // Received result-generated event
                break;
            case 'task-finished':
                echo "Task completed\n";
                $conn->close();
                break;
            case 'task-failed':
                echo "Task failed\n";
                echo "Error code: " . $response['header']['error_code'] . "\n";
                echo "Error message: " . $response['header']['error_message'] . "\n";
                $conn->close();
                break;
            case 'error':
                echo "Error: " . $response['payload']['message'] . "\n";
                break;
            default:
                echo "Unknown event: " . $response['header']['event'] . "\n";
                break;
        }
    
        // If the task is completed, close the connection
        if ($response['header']['event'] == 'task-finished') {
            // Wait 1 second to ensure all data has been transmitted
            $loop->addTimer(1, function() use ($conn) {
                $conn->close();
                echo "Client closing connection\n";
            });
        }
    
        // If the task-started event has not been received, close the connection
        if (!$taskStarted && in_array($response['header']['event'], ['task-failed', 'error'])) {
            $conn->close();
        }
    }

    Node.js

    Instale as dependências necessárias:

    npm install ws
    npm install uuid

    Código de exemplo:

    const WebSocket = require('ws');
    const fs = require('fs');
    const uuid = require('uuid').v4;
    
    // The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: const apiKey = "sk-xxx"
    const apiKey = process.env.DASHSCOPE_API_KEY;
    // The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
    const url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/';
    // Output file path
    const outputFilePath = 'output.mp3';
    
    // Clear output file
    fs.writeFileSync(outputFilePath, '');
    
    // Create WebSocket client
    const ws = new WebSocket(url, {
      headers: {
        Authorization: `bearer ${apiKey}`,
        'X-DashScope-DataInspection': 'enable'
      }
    });
    
    let taskStarted = false;
    let taskId = uuid();
    
    ws.on('open', () => {
      console.log('Connected to the WebSocket server');
    
      // Send the run-task event
      const runTaskMessage = JSON.stringify({
        header: {
          action: 'run-task',
          task_id: taskId,
          streaming: 'duplex'
        },
        payload: {
          task_group: 'audio',
          task: 'tts',
          function: 'SpeechSynthesizer',
          model: 'qwen-audio-3.0-tts-flash',
          parameters: {
            text_type: 'PlainText',
            voice: 'longanlingxi', // Voice
            format: 'mp3', // Audio format
            sample_rate: 22050, // Sample rate
            volume: 50, // Volume
            rate: 1, // Speech rate
            pitch: 1, // Pitch
            enable_ssml: false // Whether to enable SSML. If enable_ssml is set to true, only one continue-task event can be sent; otherwise the error "Text request limit violated, expected 1." will be returned
          },
          input: {}
        }
      });
      ws.send(runTaskMessage);
      console.log('run-task message sent');
    });
    
    const fileStream = fs.createWriteStream(outputFilePath, { flags: 'a' });
    ws.on('message', (data, isBinary) => {
      if (isBinary) {
        // Write binary data to file
        fileStream.write(data);
      } else {
        const message = JSON.parse(data);
    
        switch (message.header.event) {
          case 'task-started':
            taskStarted = true;
            console.log('Task started');
            // Send continue-task events
            sendContinueTasks(ws);
            break;
          case 'task-finished':
            console.log('Task completed');
            ws.close();
            fileStream.end(() => {
              console.log('File stream closed');
            });
            break;
          case 'task-failed':
            console.error('Task failed: ', message.header.error_message);
            ws.close();
            fileStream.end(() => {
              console.log('File stream closed');
            });
            break;
          default:
            // result-generated can be handled here
            break;
        }
      }
    });
    
    function sendContinueTasks(ws) {
      const texts = [
        'Before my bed, moonlight shines bright,',
        'I suspect it is frost upon the ground.',
        'I raise my eyes to gaze at the bright moon,',
        'then bow my head, thinking of home.'
      ];
    
      texts.forEach((text, index) => {
        setTimeout(() => {
          if (taskStarted) {
            const continueTaskMessage = JSON.stringify({
              header: {
                action: 'continue-task',
                task_id: taskId,
                streaming: 'duplex'
              },
              payload: {
                input: {
                  text: text
                }
              }
            });
            ws.send(continueTaskMessage);
            console.log(`continue-task sent, text: ${text}`);
          }
        }, index * 1000); // Send one every second
      });
    
      // Send the finish-task event
      setTimeout(() => {
        if (taskStarted) {
          const finishTaskMessage = JSON.stringify({
            header: {
              action: 'finish-task',
              task_id: taskId,
              streaming: 'duplex'
            },
            payload: {
              input: {}
            }
          });
          ws.send(finishTaskMessage);
          console.log('finish-task sent');
        }
      }, texts.length * 1000 + 1000); // Send 1 second after all continue-task events are sent
    }
    
    ws.on('close', () => {
      console.log('Disconnected from the WebSocket server');
    });

    Java

    Recomendamos o uso do SDK DashScope para Java no desenvolvimento. Consulte SDK para Java.

    A seguir, apresentamos um exemplo de conexão direta via WebSocket em Java. Importe estas dependências antes de executar:

    • Java-WebSocket

    • jackson-databind

    Utilize Maven ou Gradle para gerenciar as dependências:

    pom.xml

    <dependencies>
        <!-- WebSocket Client -->
        <dependency>
            <groupId>org.java-websocket</groupId>
            <artifactId>Java-WebSocket</artifactId>
            <version>1.5.3</version>
        </dependency>
    
        <!-- JSON Processing -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.0</version>
        </dependency>
    </dependencies>

    build.gradle

    // Other code omitted
    dependencies {
      // WebSocket Client
      implementation 'org.java-websocket:Java-WebSocket:1.5.3'
      // JSON Processing
      implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.0'
    }
    // Other code omitted

    Código Java:

    import com.fasterxml.jackson.databind.ObjectMapper;
    
    import org.java_websocket.client.WebSocketClient;
    import org.java_websocket.handshake.ServerHandshake;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.net.URI;
    import java.nio.ByteBuffer;
    import java.util.*;
    
    public class TTSWebSocketClient extends WebSocketClient {
        private final String taskId = UUID.randomUUID().toString();
        private final String outputFile = "output_" + System.currentTimeMillis() + ".mp3";
        private boolean taskFinished = false;
    
        public TTSWebSocketClient(URI serverUri, Map<String, String> headers) {
            super(serverUri, headers);
        }
    
        @Override
        public void onOpen(ServerHandshake serverHandshake) {
            System.out.println("Connection established");
    
            // Send the run-task event
            // If enable_ssml is set to true, only one continue-task event can be sent; otherwise the error "Text request limit violated, expected 1." will be returned
            String runTaskCommand = "{ \"header\": { \"action\": \"run-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"task_group\": \"audio\", \"task\": \"tts\", \"function\": \"SpeechSynthesizer\", \"model\": \"qwen-audio-3.0-tts-flash\", \"parameters\": { \"text_type\": \"PlainText\", \"voice\": \"longanlingxi\", \"format\": \"mp3\", \"sample_rate\": 22050, \"volume\": 50, \"rate\": 1, \"pitch\": 1, \"enable_ssml\": false }, \"input\": {} }}";
            send(runTaskCommand);
        }
    
        @Override
        public void onMessage(String message) {
            System.out.println("Received message from server: " + message);
            try {
                // Parse JSON message
                Map<String, Object> messageMap = new ObjectMapper().readValue(message, Map.class);
    
                if (messageMap.containsKey("header")) {
                    Map<String, Object> header = (Map<String, Object>) messageMap.get("header");
    
                    if (header.containsKey("event")) {
                        String event = (String) header.get("event");
    
                        if ("task-started".equals(event)) {
                            System.out.println("Received task-started event from server");
    
                            List<String> texts = Arrays.asList(
                                    "Before my bed, moonlight shines bright,I suspect it\'s frost upon the ground.",
                                    "I raise my eyes to gaze at the bright moon,then bow my head, thinking of home."
                            );
    
                            for (String text : texts) {
                                // Send the continue-task event
                                sendContinueTask(text);
                            }
    
                            // Send the finish-task event
                            sendFinishTask();
                        } else if ("task-finished".equals(event)) {
                            System.out.println("Received task-finished event from server");
                            taskFinished = true;
                            closeConnection();
                        } else if ("task-failed".equals(event)) {
                            System.out.println("Task failed: " + message);
                            closeConnection();
                        }
                    }
                }
            } catch (Exception e) {
                System.err.println("Exception occurred: " + e.getMessage());
            }
        }
    
        @Override
        public void onMessage(ByteBuffer message) {
            System.out.println("Received binary audio data of size: " + message.remaining());
    
            try (FileOutputStream fos = new FileOutputStream(outputFile, true)) {
                byte[] buffer = new byte[message.remaining()];
                message.get(buffer);
                fos.write(buffer);
                System.out.println("Audio data written to local file " + outputFile);
            } catch (IOException e) {
                System.err.println("Failed to write audio data to local file: " + e.getMessage());
            }
        }
    
        @Override
        public void onClose(int code, String reason, boolean remote) {
            System.out.println("Connection closed: " + reason + " (" + code + ")");
        }
    
        @Override
        public void onError(Exception ex) {
            System.err.println("Error: " + ex.getMessage());
            ex.printStackTrace();
        }
    
        private void sendContinueTask(String text) {
            String command = "{ \"header\": { \"action\": \"continue-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": { \"text\": \"" + text + "\" } }}";
            send(command);
        }
    
        private void sendFinishTask() {
            String command = "{ \"header\": { \"action\": \"finish-task\", \"task_id\": \"" + taskId + "\", \"streaming\": \"duplex\" }, \"payload\": { \"input\": {} }}";
            send(command);
        }
    
        private void closeConnection() {
            if (!isClosed()) {
                close();
            }
        }
    
        public static void main(String[] args) {
            try {
                // The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
                // If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: String apiKey = "sk-xxx"
                String apiKey = System.getenv("DASHSCOPE_API_KEY");
                if (apiKey == null || apiKey.isEmpty()) {
                    System.err.println("Please set the DASHSCOPE_API_KEY environment variable");
                    return;
                }
    
                Map<String, String> headers = new HashMap<>();
                headers.put("Authorization", "bearer " + apiKey);
                // The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
                TTSWebSocketClient client = new TTSWebSocketClient(new URI("wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/"), headers);
    
                client.connect();
    
                while (!client.isClosed() && !client.taskFinished) {
                    Thread.sleep(1000);
                }
            } catch (Exception e) {
                System.err.println("Failed to connect to WebSocket service: " + e.getMessage());
                e.printStackTrace();
            }
        }
    }

    Python

    Recomendamos o uso do SDK DashScope para Python no desenvolvimento. Consulte SDK para Python.

    A seguir, apresentamos um exemplo de conexão direta via WebSocket em Python. Instale estas dependências antes de executar:

    pip uninstall websocket-client
    pip uninstall websocket
    pip install websocket-client

    Importante

    Não nomeie o arquivo Python como "websocket.py", caso contrário, ocorrerá um erro (AttributeError: module 'websocket' has no attribute 'WebSocketApp'. Did you mean: 'WebSocket'?).

    import websocket
    import json
    import uuid
    import os
    import time
    
    class TTSClient:
        def __init__(self, api_key, uri):
            """
        Initialize TTSClient instance
    
        Parameters:
            api_key (str): API Key for authentication
            uri (str): WebSocket service URL
        """
            self.api_key = api_key  # Replace with your API Key
            self.uri = uri  # Replace with your WebSocket URL
            self.task_id = str(uuid.uuid4())  # Generate unique task ID
            self.output_file = f"output_{int(time.time())}.mp3"  # Output audio file path
            self.ws = None  # WebSocketApp instance
            self.task_started = False  # Whether task-started has been received
            self.task_finished = False  # Whether task-finished / task-failed has been received
    
        def on_open(self, ws):
            """
        Callback when WebSocket connection is established
        Sends run-task event to start speech synthesis task
        """
            print("WebSocket connected")
    
            # Construct run-task event
            run_task_cmd = {
                "header": {
                    "action": "run-task",
                    "task_id": self.task_id,
                    "streaming": "duplex"
                },
                "payload": {
                    "task_group": "audio",
                    "task": "tts",
                    "function": "SpeechSynthesizer",
                    "model": "qwen-audio-3.0-tts-flash",
                    "parameters": {
                        "text_type": "PlainText",
                        "voice": "longanlingxi",
                        "format": "mp3",
                        "sample_rate": 22050,
                        "volume": 50,
                        "rate": 1,
                        "pitch": 1,
                        # If enable_ssml is set to true, only one continue-task event can be sent; otherwise an error will be returned
                        "enable_ssml": False
                    },
                    "input": {}
                }
            }
    
            # Send run-task event
            ws.send(json.dumps(run_task_cmd))
            print("Sent run-task event")
    
        def on_message(self, ws, message):
            """
        Callback when a message is received
        Handles text and binary messages differently
        """
            if isinstance(message, str):
                # Handle JSON text messages
                try:
                    msg_json = json.loads(message)
                    print(f"Received JSON message: {msg_json}")
    
                    if "header" in msg_json:
                        header = msg_json["header"]
    
                        if "event" in header:
                            event = header["event"]
    
                            if event == "task-started":
                                print("Task started")
                                self.task_started = True
    
                                # Send continue-task events
                                texts = [
                                    "Before my bed, moonlight shines bright,I suspect it\'s frost upon the ground.",
                                    "I raise my eyes to gaze at the bright moon,then bow my head, thinking of home."
                                ]
    
                                for text in texts:
                                    self.send_continue_task(text)
    
                                # Send finish-task after all continue-task events are sent
                                self.send_finish_task()
    
                            elif event == "task-finished":
                                print("Task completed")
                                self.task_finished = True
                                self.close(ws)
    
                            elif event == "task-failed":
                                error_msg = msg_json.get("error_message", "Unknown error")
                                print(f"Task failed: {error_msg}")
                                self.task_finished = True
                                self.close(ws)
    
                except json.JSONDecodeError as e:
                    print(f"JSON parsing failed: {e}")
            else:
                # Handle binary messages (audio data)
                print(f"Received binary message, size: {len(message)} bytes")
                with open(self.output_file, "ab") as f:
                    f.write(message)
                print(f"Audio data written to local file {self.output_file}")
    
        def on_error(self, ws, error):
            """Callback when an error occurs"""
            print(f"WebSocket error: {error}")
    
        def on_close(self, ws, close_status_code, close_msg):
            """Callback when connection is closed"""
            print(f"WebSocket closed: {close_msg} ({close_status_code})")
    
        def send_continue_task(self, text):
            """Send continue-task event with text content to be synthesized"""
            cmd = {
                "header": {
                    "action": "continue-task",
                    "task_id": self.task_id,
                    "streaming": "duplex"
                },
                "payload": {
                    "input": {
                        "text": text
                    }
                }
            }
    
            self.ws.send(json.dumps(cmd))
            print(f"Sent continue-task event, text content: {text}")
    
        def send_finish_task(self):
            """Send finish-task event to end the speech synthesis task"""
            cmd = {
                "header": {
                    "action": "finish-task",
                    "task_id": self.task_id,
                    "streaming": "duplex"
                },
                "payload": {
                    "input": {}
                }
            }
    
            self.ws.send(json.dumps(cmd))
            print("Sent finish-task event")
    
        def close(self, ws):
            """Actively close the connection"""
            if ws and ws.sock and ws.sock.connected:
                ws.close()
                print("Connection closed actively")
    
        def run(self):
            """Start the WebSocket client"""
            # Set request headers (authentication)
            header = {
                "Authorization": f"bearer {self.api_key}",
                "X-DashScope-DataInspection": "enable"
            }
    
            # Create WebSocketApp instance
            self.ws = websocket.WebSocketApp(
                self.uri,
                header=header,
                on_open=self.on_open,
                on_message=self.on_message,
                on_error=self.on_error,
                on_close=self.on_close
            )
    
            print("Listening for WebSocket messages...")
            self.ws.run_forever()  # Start persistent connection listener
    
    # Example usage
    if __name__ == "__main__":
        # The API Key differs between the Singapore and Beijing regions. Get your API Key: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
        # If you have not configured the environment variable, replace the next line with your Chinese Model Studio API Key: API_KEY = "sk-xxx"
        API_KEY = os.environ.get("DASHSCOPE_API_KEY")
        # The following is the configuration for the Singapore region. Replace "{WorkspaceId}" with your actual workspace ID. The configuration varies by region.
        SERVER_URI = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference/"  # Replace with your WebSocket URL
    
        client = TTSClient(API_KEY, SERVER_URI)
        client.run()