Alibaba Cloud Model Studio:リアルタイム音声認識 - Qwen

Python

例を実行する前に、以下のコマンドで依存関係をインストールしてください:

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

例のファイル名を websocket.py にしないでください。この名前は websocket ライブラリと競合し、次のエラーが発生します: AttributeError: module 'websocket' has no attribute 'WebSocketApp'. Did you mean: 'WebSocket'?。

# pip install websocket-client
import os
import json
import time
import uuid
import threading
import websocket

# API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: api_key = "sk-xxx"
api_key = os.environ.get('DASHSCOPE_API_KEY')
# 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference'  # WebSocket サーバーアドレス
audio_file = '{YOUR_AUDIO_FILE}'  # 音声ファイルのパスに置き換えてください

# 32 文字のランダム ID を生成
TASK_ID = uuid.uuid4().hex[:32]

task_started = False  # タスクが開始されたかどうかを示すフラグ

# run-task 命令を送信
def send_run_task(ws):
    run_task_message = {
        'header': {
            'action': 'run-task',
            'task_id': TASK_ID,
            'streaming': 'duplex'
        },
        'payload': {
            'task_group': 'audio',
            'task': 'asr',
            'function': 'recognition',
            'model': 'qwen-audio-3.0-asr-flash-streaming',
            'parameters': {
                'sample_rate': 16000,
                'format': 'wav'
            },
            'input': {}
        }
    }
    ws.send(json.dumps(run_task_message))

# finish-task 命令を送信
def send_finish_task(ws):
    finish_task_message = {
        'header': {
            'action': 'finish-task',
            'task_id': TASK_ID,
            'streaming': 'duplex'
        },
        'payload': {
            'input': {}
        }
    }
    ws.send(json.dumps(finish_task_message))

# 音声ストリームを送信 (100ms ごとに 1 つのバイナリチャンクを送信)
def send_audio_stream(ws):
    chunk_size = 3200  # 16kHz 16bit モノラルで 100ms
    try:
        with open(audio_file, 'rb') as f:
            while True:
                chunk = f.read(chunk_size)
                if not chunk:
                    break
                ws.send(chunk, opcode=websocket.ABNF.OPCODE_BINARY)
                time.sleep(0.1)
        print('音声ストリーム終了')
        send_finish_task(ws)
    except Exception as e:
        print('音声ファイルの読み取りエラー:', e)
        ws.close()

# 接続が開いたときに run-task 命令を送信
def on_open(ws):
    print('サーバーに接続しました')
    send_run_task(ws)

# 受信メッセージを処理
def on_message(ws, data):
    global task_started
    message = json.loads(data)
    event = message['header']['event']
    if event == 'task-started':
        print('タスク開始')
        task_started = True
        threading.Thread(target=send_audio_stream, args=(ws,), daemon=True).start()
    elif event == 'result-generated':
        print('認識結果:', message['payload']['output']['sentence']['text'])
        if message['payload'].get('usage'):
            print('タスク課金時間 (秒):', message['payload']['usage']['duration'])
    elif event == 'task-finished':
        print('タスク完了')
        ws.close()
    elif event == 'task-failed':
        print('タスク失敗:', message['header'].get('error_message'))
        ws.close()
    else:
        print('不明なイベント:', event)

# task-started イベントが受信されない場合に接続を閉じる
def on_close(ws, close_status_code, close_msg):
    if not task_started:
        print('タスクが開始されていません。接続を閉じます')

# エラー処理
def on_error(ws, error):
    print('WebSocket エラー:', error)

if __name__ == '__main__':
    ws = websocket.WebSocketApp(
        url,
        header={'Authorization': f'bearer {api_key}'},
        on_open=on_open,
        on_message=on_message,
        on_error=on_error,
        on_close=on_close
    )
    ws.run_forever()

Java

例を実行する前に、Java-WebSocket 依存関係をインストールしてください:

<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.6</version>
</dependency>
<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20240303</version>
</dependency>

implementation 'org.java-websocket:Java-WebSocket:1.5.6'
implementation 'org.json:json:20240303'

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicBoolean;

public class FunASRRealtimeClient {

    // API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: private static final String API_KEY = "sk-xxx";
    private static final String API_KEY = System.getenv().getOrDefault("DASHSCOPE_API_KEY", "sk-xxx");
    // 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
    private static final String URL = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference";
    private static final String AUDIO_FILE = "{YOUR_AUDIO_FILE}"; // 音声ファイルのパスに置き換えてください
    private static final String MODEL = "qwen-audio-3.0-asr-flash-streaming";

    // 32 文字のランダム ID を生成
    private static final String TASK_ID = UUID.randomUUID().toString().replace("-", "").substring(0, 32);

    private static final AtomicBoolean taskStarted = new AtomicBoolean(false);
    private static WebSocketClient client;

    public static void main(String[] args) throws Exception {
        client = new WebSocketClient(new URI(URL)) {
            @Override
            public void onOpen(ServerHandshake handshake) {
                System.out.println("サーバーに接続しました");
                sendRunTask();
            }

            @Override
            public void onMessage(String data) {
                JSONObject message = new JSONObject(data);
                String event = message.getJSONObject("header").getString("event");
                switch (event) {
                    case "task-started":
                        System.out.println("タスク開始");
                        taskStarted.set(true);
                        new Thread(FunASRRealtimeClient::sendAudioStream).start();
                        break;
                    case "result-generated":
                        JSONObject payload = message.getJSONObject("payload");
                        String text = payload.getJSONObject("output").getJSONObject("sentence").getString("text");
                        System.out.println("認識結果: " + text);
                        if (payload.has("usage")) {
                            System.out.println("タスク課金時間 (秒): " + payload.getJSONObject("usage").get("duration"));
                        }
                        break;
                    case "task-finished":
                        System.out.println("タスク完了");
                        close();
                        break;
                    case "task-failed":
                        String errMsg = message.getJSONObject("header").optString("error_message");
                        System.err.println("タスク失敗: " + errMsg);
                        close();
                        break;
                    default:
                        System.out.println("不明なイベント: " + event);
                }
            }

            @Override
            public void onClose(int code, String reason, boolean remote) {
                if (!taskStarted.get()) {
                    System.err.println("タスクが開始されていません。接続を閉じます");
                }
            }

            @Override
            public void onError(Exception ex) {
                System.err.println("WebSocket エラー: " + ex.getMessage());
            }
        };
        client.addHeader("Authorization", "bearer " + API_KEY);
        client.connectBlocking();
    }

    // run-task 命令を送信
    private static void sendRunTask() {
        JSONObject runTask = new JSONObject()
                .put("header", new JSONObject()
                        .put("action", "run-task")
                        .put("task_id", TASK_ID)
                        .put("streaming", "duplex"))
                .put("payload", new JSONObject()
                        .put("task_group", "audio")
                        .put("task", "asr")
                        .put("function", "recognition")
                        .put("model", MODEL)
                        .put("parameters", new JSONObject()
                                .put("sample_rate", 16000)
                                .put("format", "wav"))
                        .put("input", new JSONObject()));
        client.send(runTask.toString());
    }

    // 音声ストリームを送信 (100ms ごとに 1 つのバイナリチャンクを送信)
    private static void sendAudioStream() {
        int chunkSize = 3200; // 16kHz 16bit モノラルで 100ms
        try {
            byte[] audio = Files.readAllBytes(Paths.get(AUDIO_FILE));
            int offset = 0;
            while (offset < audio.length) {
                int end = Math.min(offset + chunkSize, audio.length);
                byte[] chunk = new byte[end - offset];
                System.arraycopy(audio, offset, chunk, 0, end - offset);
                client.send(ByteBuffer.wrap(chunk));
                offset = end;
                Thread.sleep(100);
            }
            System.out.println("音声ストリーム終了");
            sendFinishTask();
        } catch (Exception e) {
            System.err.println("音声ファイルの読み取りエラー: " + e.getMessage());
            client.close();
        }
    }

    // finish-task 命令を送信
    private static void sendFinishTask() {
        JSONObject finishTask = new JSONObject()
                .put("header", new JSONObject()
                        .put("action", "finish-task")
                        .put("task_id", TASK_ID)
                        .put("streaming", "duplex"))
                .put("payload", new JSONObject()
                        .put("input", new JSONObject()));
        client.send(finishTask.toString());
    }
}

Node.js

必要な依存関係をインストールします:

npm install ws
npm install uuid

サンプルコードは以下の通りです:

const fs = require('fs');
const WebSocket = require('ws');
const { v4: uuidv4 } = require('uuid'); // UUID を生成するために使用

// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: const apiKey = "sk-xxx"
const apiKey = process.env.DASHSCOPE_API_KEY;
// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
const url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference'; // WebSocket サーバーアドレス
const audioFile = '{YOUR_AUDIO_FILE}'; // 音声ファイルのパスに置き換えてください

// 32 文字のランダム ID を生成
const TASK_ID = uuidv4().replace(/-/g, '').slice(0, 32);

// WebSocket クライアントを作成
const ws = new WebSocket(url, {
  headers: {
    Authorization: `bearer ${apiKey}`
  }
});

let taskStarted = false; // タスクが開始されたかどうかを示すフラグ

// 接続が開いたときに run-task 命令を送信
ws.on('open', () => {
  console.log('サーバーに接続しました');
  sendRunTask();
});

// 受信メッセージを処理
ws.on('message', (data) => {
  const message = JSON.parse(data);
  switch (message.header.event) {
    case 'task-started':
      console.log('タスク開始');
      taskStarted = true;
      sendAudioStream();
      break;
    case 'result-generated':
      console.log('認識結果:', message.payload.output.sentence.text);
      if (message.payload.usage) {
        console.log('タスク課金時間 (秒):', message.payload.usage.duration);
      }
      break;
    case 'task-finished':
      console.log('タスク完了');
      ws.close();
      break;
    case 'task-failed':
      console.error('タスク失敗:', message.header.error_message);
      ws.close();
      break;
    default:
      console.log('不明なイベント:', message.header.event);
  }
});

// task-started イベントが受信されない場合に接続を閉じる
ws.on('close', () => {
  if (!taskStarted) {
    console.error('タスクが開始されていません。接続を閉じます');
  }
});

// run-task 命令を送信
function sendRunTask() {
  const runTaskMessage = {
    header: {
      action: 'run-task',
      task_id: TASK_ID,
      streaming: 'duplex'
    },
    payload: {
      task_group: 'audio',
      task: 'asr',
      function: 'recognition',
      model: 'qwen-audio-3.0-asr-flash-streaming',
      parameters: {
        sample_rate: 16000,
        format: 'wav'
      },
      input: {}
    }
  };
  ws.send(JSON.stringify(runTaskMessage));
}

// 音声ストリームを送信
function sendAudioStream() {
  const audioStream = fs.createReadStream(audioFile);
  let chunkCount = 0;

  function sendNextChunk() {
    const chunk = audioStream.read();
    if (chunk) {
      ws.send(chunk);
      chunkCount++;
      setTimeout(sendNextChunk, 100); // 100ms ごとに送信
    }
  }

  audioStream.on('readable', () => {
    sendNextChunk();
  });

  audioStream.on('end', () => {
    console.log('音声ストリーム終了');
    sendFinishTask();
  });

  audioStream.on('error', (err) => {
    console.error('音声ファイルの読み取りエラー:', err);
    ws.close();
  });
}

// finish-task 命令を送信
function sendFinishTask() {
  const finishTaskMessage = {
    header: {
      action: 'finish-task',
      task_id: TASK_ID,
      streaming: 'duplex'
    },
    payload: {
      input: {}
    }
  };
  ws.send(JSON.stringify(finishTaskMessage));
}

// エラー処理
ws.on('error', (error) => {
  console.error('WebSocket エラー:', error);
});

C#

サンプルコードは以下の通りです:

using System.Net.WebSockets;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;

class Program {
    private static ClientWebSocket _webSocket = new ClientWebSocket();
    private static CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
    private static bool _taskStartedReceived = false;
    private static bool _taskFinishedReceived = false;
    // API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: private static readonly string ApiKey = "sk-xxx"
    private static readonly string ApiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY") ?? throw new InvalidOperationException("DASHSCOPE_API_KEY 環境変数が設定されていません。");

    // 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
    private const string WebSocketUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference";
    // 音声ファイルのパスに置き換えてください
    private const string AudioFilePath = "{YOUR_AUDIO_FILE}";

    static async Task Main(string[] args) {
        // WebSocket 接続を確立し、認証ヘッダーを設定
        _webSocket.Options.SetRequestHeader("Authorization", $"bearer {ApiKey}");

        await _webSocket.ConnectAsync(new Uri(WebSocketUrl), _cancellationTokenSource.Token);

        // WebSocket メッセージを非同期で受信するスレッドを開始
        var receiveTask = ReceiveMessagesAsync();

        // run-task 命令を送信
        string _taskId = Guid.NewGuid().ToString("N"); // 32 文字のランダム ID を生成
        var runTaskJson = GenerateRunTaskJson(_taskId);
        await SendAsync(runTaskJson);

        // task-started イベントを待機
        while (!_taskStartedReceived) {
            await Task.Delay(100, _cancellationTokenSource.Token);
        }

        // ローカルファイルを読み込み、認識対象の音声ストリームをサーバーに送信
        await SendAudioStreamAsync(AudioFilePath);

        // finish-task 命令を送信してタスクを終了
        var finishTaskJson = GenerateFinishTaskJson(_taskId);
        await SendAsync(finishTaskJson);

        // task-finished イベントを待機
        while (!_taskFinishedReceived && !_cancellationTokenSource.IsCancellationRequested) {
            try {
                await Task.Delay(100, _cancellationTokenSource.Token);
            } catch (OperationCanceledException) {
                // タスクがキャンセルされたため、ループを終了
                break;
            }
        }

        // 接続を閉じる
        if (!_cancellationTokenSource.IsCancellationRequested) {
            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", _cancellationTokenSource.Token);
        }

        _cancellationTokenSource.Cancel();
        try {
            await receiveTask;
        } catch (OperationCanceledException) {
            // 操作キャンセル例外を無視
        }
    }

    private static async Task ReceiveMessagesAsync() {
        try {
            while (_webSocket.State == WebSocketState.Open && !_cancellationTokenSource.IsCancellationRequested) {
                var message = await ReceiveMessageAsync(_cancellationTokenSource.Token);
                if (message != null) {
                    var eventValue = message["header"]?["event"]?.GetValue<string>();
                    switch (eventValue) {
                        case "task-started":
                            Console.WriteLine("タスクが正常に開始されました");
                            _taskStartedReceived = true;
                            break;
                        case "result-generated":
                            Console.WriteLine($"認識結果: {message["payload"]?["output"]?["sentence"]?["text"]?.GetValue<string>()}");
                            if (message["payload"]?["usage"] != null && message["payload"]?["usage"]?["duration"] != null) {
                                Console.WriteLine($"タスク課金時間 (秒): {message["payload"]?["usage"]?["duration"]?.GetValue<int>()}");
                            }
                            break;
                        case "task-finished":
                            Console.WriteLine("タスク完了");
                            _taskFinishedReceived = true;
                            _cancellationTokenSource.Cancel();
                            break;
                        case "task-failed":
                            Console.WriteLine($"タスク失敗: {message["header"]?["error_message"]?.GetValue<string>()}");
                            _cancellationTokenSource.Cancel();
                            break;
                    }
                }
            }
        } catch (OperationCanceledException) {
            // 操作キャンセル例外を無視
        }
    }

    private static async Task<JsonNode?> ReceiveMessageAsync(CancellationToken cancellationToken) {
        var buffer = new byte[1024 * 4];
        var segment = new ArraySegment<byte>(buffer);
        var result = await _webSocket.ReceiveAsync(segment, cancellationToken);

        if (result.MessageType == WebSocketMessageType.Close) {
            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", cancellationToken);
            return null;
        }

        var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
        return JsonNode.Parse(message);
    }

    private static async Task SendAsync(string message) {
        var buffer = Encoding.UTF8.GetBytes(message);
        var segment = new ArraySegment<byte>(buffer);
        await _webSocket.SendAsync(segment, WebSocketMessageType.Text, true, _cancellationTokenSource.Token);
    }

    private static async Task SendAudioStreamAsync(string filePath) {
        using (var audioStream = File.OpenRead(filePath)) {
            var buffer = new byte[1024]; // 100ms 分の音声データを送信
            int bytesRead;

            while ((bytesRead = await audioStream.ReadAsync(buffer, 0, buffer.Length)) > 0) {
                var segment = new ArraySegment<byte>(buffer, 0, bytesRead);
                await _webSocket.SendAsync(segment, WebSocketMessageType.Binary, true, _cancellationTokenSource.Token);
                await Task.Delay(100); // 100ms 間隔
            }
        }
    }

    private static string GenerateRunTaskJson(string taskId) {
        var runTask = new JsonObject {
            ["header"] = new JsonObject {
                ["action"] = "run-task",
                ["task_id"] = taskId,
                ["streaming"] = "duplex"
            },
            ["payload"] = new JsonObject {
                ["task_group"] = "audio",
                ["task"] = "asr",
                ["function"] = "recognition",
                ["model"] = "qwen-audio-3.0-asr-flash-streaming",
                ["parameters"] = new JsonObject {
                    ["format"] = "wav",
                    ["sample_rate"] = 16000,
                },
                ["input"] = new JsonObject()
            }
        };
        return JsonSerializer.Serialize(runTask);
    }

    private static string GenerateFinishTaskJson(string taskId) {
        var finishTask = new JsonObject {
            ["header"] = new JsonObject {
                ["action"] = "finish-task",
                ["task_id"] = taskId,
                ["streaming"] = "duplex"
            },
            ["payload"] = new JsonObject {
                ["input"] = new JsonObject()
            }
        };
        return JsonSerializer.Serialize(finishTask);
    }
}

PHP

サンプルプロジェクトのディレクトリ構造は以下の通りです:

my-php-project/

├── composer.json

├── vendor/

└── index.php

composer.json の内容は以下の通りです。必要に応じて依存関係のバージョンを調整してください:

{
    "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/"
        }
    }
}

index.php の内容は以下の通りです:

<?php

require __DIR__ . '/vendor/autoload.php';

use Ratchet\Client\Connector;
use React\EventLoop\Loop;
use React\Socket\Connector as SocketConnector;
use Ratchet\rfc6455\Messaging\Frame;

// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: $api_key = "sk-xxx"
$api_key = getenv("DASHSCOPE_API_KEY");
// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
$websocket_url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference';
$audio_file_path = '{YOUR_AUDIO_FILE}'; // 音声ファイルのパスに置き換えてください

$loop = Loop::get();

// カスタムコネクタを作成
$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
];

$connector($websocket_url, [], $headers)->then(function ($conn) use ($loop, $audio_file_path) {
    echo "WebSocket サーバーに接続しました\n";

    // WebSocket メッセージを非同期で受信するスレッドを開始
    $conn->on('message', function($msg) use ($conn, $loop, $audio_file_path) {
        $response = json_decode($msg, true);

        if (isset($response['header']['event'])) {
            handleEvent($conn, $response, $loop, $audio_file_path);
        } else {
            echo "不明なメッセージ形式\n";
        }
    });

    // 接続クローズをリッスン
    $conn->on('close', function($code = null, $reason = null) {
        echo "接続が閉じられました\n";
        if ($code !== null) {
            echo "クローズコード: " . $code . "\n";
        }
        if ($reason !== null) {
            echo "クローズ理由: " . $reason . "\n";
        }
    });

    // タスク ID を生成
    $taskId = generateTaskId();

    // run-task 命令を送信
    sendRunTaskMessage($conn, $taskId);

}, function ($e) {
    echo "接続できません: {$e->getMessage()}\n";
});

$loop->run();

/**
 * タスク ID を生成
 * @return string
 */
function generateTaskId(): string {
    return bin2hex(random_bytes(16));
}

/**
 * run-task 命令を送信
 * @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" => "asr",
            "function" => "recognition",
            "model" => "qwen-audio-3.0-asr-flash-streaming",
            "parameters" => [
                "format" => "wav",
                "sample_rate" => 16000
            ],
            "input" => []
        ]
    ]);
    echo "run-task 命令の送信準備: " . $runTaskMessage . "\n";
    $conn->send($runTaskMessage);
    echo "run-task 命令を送信しました\n";
}

/**
 * 音声ファイルを読み込む
 * @param string $filePath
 * @return bool|string
 */
function readAudioFile(string $filePath) {
    $voiceData = file_get_contents($filePath);
    if ($voiceData === false) {
        echo "音声ファイルを読み込めません\n";
    }
    return $voiceData;
}

/**
 * 音声データを分割
 * @param string $data
 * @param int $chunkSize
 * @return array
 */
function splitAudioData(string $data, int $chunkSize): array {
    return str_split($data, $chunkSize);
}

/**
 * finish-task 命令を送信
 * @param $conn
 * @param $taskId
 */
function sendFinishTaskMessage($conn, $taskId) {
    $finishTaskMessage = json_encode([
        "header" => [
            "action" => "finish-task",
            "task_id" => $taskId,
            "streaming" => "duplex"
        ],
        "payload" => [
            "input" => []
        ]
    ]);
    echo "finish-task 命令の送信準備: " . $finishTaskMessage . "\n";
    $conn->send($finishTaskMessage);
    echo "finish-task 命令を送信しました\n";
}

/**
 * イベントを処理
 * @param $conn
 * @param $response
 * @param $loop
 * @param $audio_file_path
 */
function handleEvent($conn, $response, $loop, $audio_file_path) {
    static $taskId;
    static $chunks;
    static $allChunksSent = false;

    if (is_null($taskId)) {
        $taskId = generateTaskId();
    }

    switch ($response['header']['event']) {
        case 'task-started':
            echo "タスク開始、音声データを送信中...\n";
            // 音声ファイルを読み込む
            $voiceData = readAudioFile($audio_file_path);
            if ($voiceData === false) {
                echo "音声ファイルを読み込めません\n";
                $conn->close();
                return;
            }

            // 音声データを分割
            $chunks = splitAudioData($voiceData, 1024);

            // 送信関数を定義
            $sendChunk = function() use ($conn, &$chunks, $loop, &$sendChunk, &$allChunksSent, $taskId) {
                if (!empty($chunks)) {
                    $chunk = array_shift($chunks);
                    $binaryMsg = new Frame($chunk, true, Frame::OP_BINARY);
                    $conn->send($binaryMsg);
                    // 次のチャンクを 100ms 後に送信
                    $loop->addTimer(0.1, $sendChunk);
                } else {
                    echo "すべてのデータチャンクを送信しました\n";
                    $allChunksSent = true;

                    // finish-task 命令を送信
                    sendFinishTaskMessage($conn, $taskId);
                }
            };

            // 音声データの送信を開始
            $sendChunk();
            break;
        case 'result-generated':
            $result = $response['payload']['output']['sentence'];
            echo "認識結果: " . $result['text'] . "\n";
            if (isset($response['payload']['usage']['duration'])) {
                echo "タスク課金時間 (秒): " . $response['payload']['usage']['duration'] . "\n";
            }
            break;
        case 'task-finished':
            echo "タスク完了\n";
            $conn->close();
            break;
        case 'task-failed':
            echo "タスク失敗\n";
            echo "エラーコード: " . $response['header']['error_code'] . "\n";
            echo "エラーメッセージ: " . $response['header']['error_message'] . "\n";
            $conn->close();
            break;
        case 'error':
            echo "エラー: " . $response['payload']['message'] . "\n";
            break;
        default:
            echo "不明なイベント: " . $response['header']['event'] . "\n";
            break;
    }

    // すべてのデータが送信され、タスクが完了した場合、接続を閉じる
    if ($allChunksSent && $response['header']['event'] == 'task-finished') {
        // すべてのデータが送信されたことを確認するために 1 秒待機
        $loop->addTimer(1, function() use ($conn) {
            $conn->close();
            echo "クライアントが接続を閉じました\n";
        });
    }
}

Go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	"github.com/google/uuid"
	"github.com/gorilla/websocket"
)

const (
	// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
	wsURL     = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/inference" // WebSocket サーバーアドレス
	audioFile = "{YOUR_AUDIO_FILE}"                                   // 音声ファイルのパスに置き換えてください
)

var dialer = websocket.DefaultDialer

func main() {
	// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: apiKey := "sk-xxx"
	apiKey := os.Getenv("DASHSCOPE_API_KEY")

	// WebSocket サービスに接続
	conn, err := connectWebSocket(apiKey)
	if err != nil {
		log.Fatal("WebSocket への接続に失敗しました: ", err)
	}
	defer closeConnection(conn)

	// 結果を受信するゴルーチンを開始
	taskStarted := make(chan bool)
	taskDone := make(chan bool)
	startResultReceiver(conn, taskStarted, taskDone)

	// run-task 命令を送信
	taskID, err := sendRunTaskCmd(conn)
	if err != nil {
		log.Fatal("run-task 命令の送信に失敗しました: ", err)
	}

	// task-started イベントを待機
	waitForTaskStarted(taskStarted)

	// 認識対象の音声ファイルストリームを送信
	if err := sendAudioData(conn); err != nil {
		log.Fatal("音声の送信に失敗しました: ", err)
	}

	// finish-task 命令を送信
	if err := sendFinishTaskCmd(conn, taskID); err != nil {
		log.Fatal("finish-task 命令の送信に失敗しました: ", err)
	}

	// タスクの完了または失敗を待機
	<-taskDone
}

// JSON データを表す構造体を定義
type Header struct {
	Action       string                 `json:"action"`
	TaskID       string                 `json:"task_id"`
	Streaming    string                 `json:"streaming"`
	Event        string                 `json:"event"`
	ErrorCode    string                 `json:"error_code,omitempty"`
	ErrorMessage string                 `json:"error_message,omitempty"`
	Attributes   map[string]interface{} `json:"attributes"`
}

type Output struct {
	Sentence struct {
		BeginTime int64  `json:"begin_time"`
		EndTime   *int64 `json:"end_time"`
		Text      string `json:"text"`
		Words     []struct {
			BeginTime   int64  `json:"begin_time"`
			EndTime     *int64 `json:"end_time"`
			Text        string `json:"text"`
			Punctuation string `json:"punctuation"`
		} `json:"words"`
	} `json:"sentence"`
}

type Payload struct {
	TaskGroup  string `json:"task_group"`
	Task       string `json:"task"`
	Function   string `json:"function"`
	Model      string `json:"model"`
	Parameters Params `json:"parameters"`
	Input      Input  `json:"input"`
	Output     Output `json:"output,omitempty"`
	Usage      *struct {
		Duration int `json:"duration"`
	} `json:"usage,omitempty"`
}

type Params struct {
	Format                   string `json:"format"`
	SampleRate               int    `json:"sample_rate"`
	DisfluencyRemovalEnabled bool   `json:"disfluency_removal_enabled"`
}

type Input struct {
}

type Event struct {
	Header  Header  `json:"header"`
	Payload Payload `json:"payload"`
}

// WebSocket サービスに接続
func connectWebSocket(apiKey string) (*websocket.Conn, error) {
	header := make(http.Header)
	header.Add("Authorization", fmt.Sprintf("bearer %s", apiKey))
	conn, _, err := dialer.Dial(wsURL, header)
	return conn, err
}

// WebSocket メッセージを非同期で受信するゴルーチンを開始
func startResultReceiver(conn *websocket.Conn, taskStarted chan<- bool, taskDone chan<- bool) {
	go func() {
		for {
			_, message, err := conn.ReadMessage()
			if err != nil {
				log.Println("サーバーメッセージの解析に失敗しました: ", err)
				return
			}
			var event Event
			err = json.Unmarshal(message, &event)
			if err != nil {
				log.Println("イベントの解析に失敗しました: ", err)
				continue
			}
			if handleEvent(conn, event, taskStarted, taskDone) {
				return
			}
		}
	}()
}

// run-task 命令を送信
func sendRunTaskCmd(conn *websocket.Conn) (string, error) {
	runTaskCmd, taskID, err := generateRunTaskCmd()
	if err != nil {
		return "", err
	}
	err = conn.WriteMessage(websocket.TextMessage, []byte(runTaskCmd))
	return taskID, err
}

// run-task 命令を生成
func generateRunTaskCmd() (string, string, error) {
	taskID := uuid.New().String()
	runTaskCmd := Event{
		Header: Header{
			Action:    "run-task",
			TaskID:    taskID,
			Streaming: "duplex",
		},
		Payload: Payload{
			TaskGroup: "audio",
			Task:      "asr",
			Function:  "recognition",
			Model:     "qwen-audio-3.0-asr-flash-streaming",
			Parameters: Params{
				Format:     "wav",
				SampleRate: 16000,
			},
			Input: Input{},
		},
	}
	runTaskCmdJSON, err := json.Marshal(runTaskCmd)
	return string(runTaskCmdJSON), taskID, err
}

// task-started イベントを待機
func waitForTaskStarted(taskStarted chan bool) {
	select {
	case <-taskStarted:
		fmt.Println("タスクが正常に開始されました")
	case <-time.After(10 * time.Second):
		log.Fatal("task-started の待機がタイムアウトしました。タスクの開始に失敗しました")
	}
}

// 音声データを送信
func sendAudioData(conn *websocket.Conn) error {
	file, err := os.Open(audioFile)
	if err != nil {
		return err
	}
	defer file.Close()

	buf := make([]byte, 1024)
	for {
		n, err := file.Read(buf)
		if n == 0 {
			break
		}
		if err != nil && err != io.EOF {
			return err
		}
		err = conn.WriteMessage(websocket.BinaryMessage, buf[:n])
		if err != nil {
			return err
		}
		time.Sleep(100 * time.Millisecond)
	}
	return nil
}

// finish-task 命令を送信
func sendFinishTaskCmd(conn *websocket.Conn, taskID string) error {
	finishTaskCmd, err := generateFinishTaskCmd(taskID)
	if err != nil {
		return err
	}
	err = conn.WriteMessage(websocket.TextMessage, []byte(finishTaskCmd))
	return err
}

// finish-task 命令を生成
func generateFinishTaskCmd(taskID string) (string, error) {
	finishTaskCmd := Event{
		Header: Header{
			Action:    "finish-task",
			TaskID:    taskID,
			Streaming: "duplex",
		},
		Payload: Payload{
			Input: Input{},
		},
	}
	finishTaskCmdJSON, err := json.Marshal(finishTaskCmd)
	return string(finishTaskCmdJSON), err
}

// イベントを処理
func handleEvent(conn *websocket.Conn, event Event, taskStarted chan<- bool, taskDone chan<- bool) bool {
	switch event.Header.Event {
	case "task-started":
		fmt.Println("task-started イベントを受信しました")
		taskStarted <- true
	case "result-generated":
		if event.Payload.Output.Sentence.Text != "" {
			fmt.Println("認識結果: ", event.Payload.Output.Sentence.Text)
		}
		if event.Payload.Usage != nil {
			fmt.Println("タスク課金時間 (秒): ", event.Payload.Usage.Duration)
		}
	case "task-finished":
		fmt.Println("タスク完了")
		taskDone <- true
		return true
	case "task-failed":
		handleTaskFailed(event, conn)
		taskDone <- true
		return true
	default:
		log.Printf("予期しないイベント: %v", event)
	}
	return false
}

// task-failed イベントを処理
func handleTaskFailed(event Event, conn *websocket.Conn) {
	if event.Header.ErrorMessage != "" {
		log.Fatalf("タスク失敗: %s", event.Header.ErrorMessage)
	} else {
		log.Fatal("タスクが不明な理由で失敗しました")
	}
}

// 接続を閉じる
func closeConnection(conn *websocket.Conn) {
	if conn != nil {
		conn.Close()
	}
}

Python

例を実行する前に、以下のコマンドで依存関係をインストールしてください:

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

例のファイル名を websocket.py にしないでください。この名前は websocket ライブラリと競合し、次のエラーが発生します: AttributeError: module 'websocket' has no attribute 'WebSocketApp'. Did you mean: 'WebSocket'?。

# pip install websocket-client
import os
import time
import json
import threading
import base64
import websocket
import logging
import logging.handlers
from datetime import datetime

logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
# 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: API_KEY="sk-xxx"
API_KEY = os.environ.get("DASHSCOPE_API_KEY", "sk-xxx")
QWEN_MODEL = "qwen3-asr-flash-realtime"
# 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
baseUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime"
url = f"{baseUrl}?model={QWEN_MODEL}"
print(f"サーバーに接続中: {url}")

# 注意: 非 VAD モードでは、連続して送信される音声の累積時間が 60 秒を超えないことを推奨します
enableServerVad = True
is_running = True  # 実行フラグを追加

headers = [
    "Authorization: Bearer " + API_KEY,
    "OpenAI-Beta: realtime=v1"
]

def init_logger():
    formatter = logging.Formatter('%(asctime)s|%(levelname)s|%(message)s')
    f_handler = logging.handlers.RotatingFileHandler(
        "omni_tester.log", maxBytes=100 * 1024 * 1024, backupCount=3
    )
    f_handler.setLevel(logging.DEBUG)
    f_handler.setFormatter(formatter)

    console = logging.StreamHandler()
    console.setLevel(logging.DEBUG)
    console.setFormatter(formatter)

    logger.addHandler(f_handler)
    logger.addHandler(console)

def on_open(ws):
    logger.info("サーバーに接続しました。")

    # セッション更新イベント
    event_manual = {
        "event_id": "event_123",
        "type": "session.update",
        "session": {
            "modalities": ["text"],
            "input_audio_format": "pcm",
            "sample_rate": 16000,
            # "input_audio_transcription": {
            #     # 言語識別子、オプション。言語がわかっている場合は設定することを推奨
            #     "language": "zh"
            # },
            "turn_detection": None
        }
    }
    event_vad = {
        "event_id": "event_123",
        "type": "session.update",
        "session": {
            "modalities": ["text"],
            "input_audio_format": "pcm",
            "sample_rate": 16000,
            # "input_audio_transcription": {
            #     "language": "zh"
            # },
            "turn_detection": {
                "type": "server_vad",
                "threshold": 0.0,
                "silence_duration_ms": 400
            }
        }
    }
    if enableServerVad:
        logger.info(f"イベントを送信: {json.dumps(event_vad, indent=2)}")
        ws.send(json.dumps(event_vad))
    else:
        logger.info(f"イベントを送信: {json.dumps(event_manual, indent=2)}")
        ws.send(json.dumps(event_manual))

def on_message(ws, message):
    global is_running
    try:
        data = json.loads(message)
        logger.info(f"イベントを受信: {json.dumps(data, ensure_ascii=False, indent=2)}")
        if data.get("type") == "conversation.item.input_audio_transcription.completed":
            logger.info(f"最終文字起こし: {data.get('transcript')}")
        elif data.get("type") == "session.finished":
            logger.info("セッション完了後に WebSocket 接続を閉じています...")
            is_running = False  # 音声送信スレッドを停止
            ws.close()
    except json.JSONDecodeError:
        logger.error(f"メッセージの解析に失敗しました: {message}")

def on_error(ws, error):
    logger.error(f"エラー: {error}")

def on_close(ws, close_status_code, close_msg):
    logger.info(f"接続が閉じられました: {close_status_code} - {close_msg}")

def send_audio(ws, local_audio_path):
    time.sleep(3)  # セッション更新が完了するのを待機
    global is_running

    with open(local_audio_path, 'rb') as audio_file:
        logger.info(f"ファイル読み取り開始: {datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
        while is_running:
            audio_data = audio_file.read(3200)  # ~0.1s PCM16/16kHz
            if not audio_data:
                logger.info(f"ファイル読み取り完了: {datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]}")
                if ws.sock and ws.sock.connected:
                    if not enableServerVad:
                        commit_event = {
                            "event_id": "event_789",
                            "type": "input_audio_buffer.commit"
                        }
                        ws.send(json.dumps(commit_event))
                    finish_event = {
                        "event_id": "event_987",
                        "type": "session.finish"
                    }
                    ws.send(json.dumps(finish_event))
                break

            if not ws.sock or not ws.sock.connected:
                logger.info("WebSocket が閉じられています。音声送信を停止します。")
                break

            encoded_data = base64.b64encode(audio_data).decode('utf-8')
            eventd = {
                "event_id": f"event_{int(time.time() * 1000)}",
                "type": "input_audio_buffer.append",
                "audio": encoded_data
            }
            ws.send(json.dumps(eventd))
            logger.info(f"音声イベントを送信: {eventd['event_id']}")
            time.sleep(0.1)  # リアルタイムキャプチャをシミュレート

# ロギングを初期化
init_logger()
logger.info(f"WebSocket サーバー {url} に接続中...")

local_audio_path = "your_audio_file.pcm"
ws = websocket.WebSocketApp(
    url,
    header=headers,
    on_open=on_open,
    on_message=on_message,
    on_error=on_error,
    on_close=on_close
)

thread = threading.Thread(target=send_audio, args=(ws, local_audio_path))
thread.start()
ws.run_forever()

Java

例を実行する前に、Java-WebSocket 依存関係をインストールしてください:

<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.6</version>
</dependency>

implementation 'org.java-websocket:Java-WebSocket:1.5.6'

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import org.json.JSONObject;

import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Base64;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.*;

public class QwenASRRealtimeClient {

    private static final Logger logger = Logger.getLogger(QwenASRRealtimeClient.class.getName());
    // API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: private static final String API_KEY = "sk-xxx"
    private static final String API_KEY = System.getenv().getOrDefault("DASHSCOPE_API_KEY", "sk-xxx");
    private static final String MODEL = "qwen3-asr-flash-realtime";

    // VAD モードを使用するかどうかを制御
    private static final boolean enableServerVad = true;

    private static final AtomicBoolean isRunning = new AtomicBoolean(true);
    private static WebSocketClient client;

    public static void main(String[] args) throws Exception {
        initLogger();

        // 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
        String baseUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime";
        String url = baseUrl + "?model=" + MODEL;
        logger.info("サーバーに接続中: " + url);

        client = new WebSocketClient(new URI(url)) {
            @Override
            public void onOpen(ServerHandshake handshake) {
                logger.info("サーバーに接続しました。");
                sendSessionUpdate();
            }

            @Override
            public void onMessage(String message) {
                try {
                    JSONObject data = new JSONObject(message);
                    String eventType = data.optString("type");

                    logger.info("イベントを受信: " + data.toString(2));

                    // 最終認識結果は transcription.completed イベントにあります
                    if ("conversation.item.input_audio_transcription.completed".equals(eventType)) {
                        logger.info("最終文字起こし: " + data.optString("transcript"));
                    }

                    // finished イベントを受信したら → 送信スレッドを停止し、接続を閉じる
                    if ("session.finished".equals(eventType)) {
                        logger.info("セッション完了後に WebSocket 接続を閉じています...");

                        isRunning.set(false); // 音声送信スレッドを停止
                        if (this.isOpen()) {
                            this.close(1000, "ASR finished");
                        }
                    }
                } catch (Exception e) {
                    logger.severe("メッセージの解析に失敗しました: " + message);
                }
            }

            @Override
            public void onClose(int code, String reason, boolean remote) {
                logger.info("接続が閉じられました: " + code + " - " + reason);
            }

            @Override
            public void onError(Exception ex) {
                logger.severe("エラー: " + ex.getMessage());
            }
        };

        // リクエストヘッダーを追加
        client.addHeader("Authorization", "Bearer " + API_KEY);
        client.addHeader("OpenAI-Beta", "realtime=v1");

        client.connectBlocking(); // 接続が確立されるまでブロック

        // 認識対象の音声ファイルのパスに置き換えてください
        String localAudioPath = "your_audio_file.pcm";
        Thread audioThread = new Thread(() -> {
            try {
                sendAudio(localAudioPath);
            } catch (Exception e) {
                logger.severe("音声送信スレッドエラー: " + e.getMessage());
            }
        });
        audioThread.start();
    }

    /** セッション更新イベント (VAD の有効化/無効化) */
    private static void sendSessionUpdate() {
        JSONObject eventNoVad = new JSONObject()
                .put("event_id", "event_123")
                .put("type", "session.update")
                .put("session", new JSONObject()
                        .put("modalities", new String[]{"text"})
                        .put("input_audio_format", "pcm")
                        .put("sample_rate", 16000)
                        // .put("input_audio_transcription", new JSONObject()
                        //         .put("language", "zh"))
                        .put("turn_detection", JSONObject.NULL) // マニュアルモード
                );

        JSONObject eventVad = new JSONObject()
                .put("event_id", "event_123")
                .put("type", "session.update")
                .put("session", new JSONObject()
                        .put("modalities", new String[]{"text"})
                        .put("input_audio_format", "pcm")
                        .put("sample_rate", 16000)
                        // .put("input_audio_transcription", new JSONObject()
                        //         .put("language", "zh"))
                        .put("turn_detection", new JSONObject()
                                .put("type", "server_vad")
                                .put("threshold", 0.0)
                                .put("silence_duration_ms", 400))
                );

        if (enableServerVad) {
            logger.info("イベントを送信 (VAD):\n" + eventVad.toString(2));
            client.send(eventVad.toString());
        } else {
            logger.info("イベントを送信 (マニュアル):\n" + eventNoVad.toString(2));
            client.send(eventNoVad.toString());
        }
    }

    /** 音声ファイルストリームを送信 */
    private static void sendAudio(String localAudioPath) throws Exception {
        Thread.sleep(3000); // セッションの準備完了を待機
        byte[] allBytes = Files.readAllBytes(Paths.get(localAudioPath));
        logger.info("ファイル読み取り開始");

        int offset = 0;
        while (isRunning.get() && offset < allBytes.length) {
            int chunkSize = Math.min(3200, allBytes.length - offset);
            byte[] chunk = new byte[chunkSize];
            System.arraycopy(allBytes, offset, chunk, 0, chunkSize);
            offset += chunkSize;

            if (client != null && client.isOpen()) {
                String encoded = Base64.getEncoder().encodeToString(chunk);
                JSONObject eventd = new JSONObject()
                        .put("event_id", "event_" + System.currentTimeMillis())
                        .put("type", "input_audio_buffer.append")
                        .put("audio", encoded);

                client.send(eventd.toString());
                logger.info("音声イベントを送信: " + eventd.getString("event_id"));
            } else {
                break; // 切断後は送信を継続しない
            }

            Thread.sleep(100); // リアルタイム送信をシミュレート
        }

        logger.info("ファイル読み取り完了");

        if (client != null && client.isOpen()) {
            // 非 VAD モードではコミットが必要
            if (!enableServerVad) {
                JSONObject commitEvent = new JSONObject()
                        .put("event_id", "event_789")
                        .put("type", "input_audio_buffer.commit");
                client.send(commitEvent.toString());
                logger.info("マニュアルモードのコミットイベントを送信しました。");
            }

            JSONObject finishEvent = new JSONObject()
                    .put("event_id", "event_987")
                    .put("type", "session.finish");
            client.send(finishEvent.toString());
            logger.info("終了イベントを送信しました。");
        }
    }

    /** ロギングを初期化 */
    private static void initLogger() {
        logger.setLevel(Level.ALL);
        Logger rootLogger = Logger.getLogger("");
        for (Handler h : rootLogger.getHandlers()) {
            rootLogger.removeHandler(h);
        }

        Handler consoleHandler = new ConsoleHandler();
        consoleHandler.setLevel(Level.ALL);
        consoleHandler.setFormatter(new SimpleFormatter());
        logger.addHandler(consoleHandler);
    }
}

Node.js

例を実行する前に、以下のコマンドで依存関係をインストールしてください:

npm install ws

/**
 * Qwen-ASR リアルタイム WebSocket クライアント (Node.js 版)
 * 機能:
 * - VAD モードとマニュアルモードをサポート
 * - session.update を送信してセッションを開始
 * - input_audio_buffer.append を介して音声チャンクを継続的に送信
 * - マニュアルモードでは input_audio_buffer.commit を送信
 * - session.finish イベントを送信
 * - session.finished イベントを受信後に接続を閉じる
 */

import WebSocket from 'ws';
import fs from 'fs';

// ===== 設定 =====
// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: const API_KEY = "sk-xxx"
const API_KEY = process.env.DASHSCOPE_API_KEY || 'sk-xxx';
const MODEL = 'qwen3-asr-flash-realtime';
const enableServerVad = true; // true の場合 VAD モード、false の場合マニュアルモード
const localAudioPath = 'your_audio_file.pcm'; // PCM16、16kHz 音声ファイルのパス

// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
const baseUrl = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime';
const url = `${baseUrl}?model=${MODEL}`;

console.log(`サーバーに接続中: ${url}`);

// ===== 状態制御 =====
let isRunning = true;

// ===== 接続を確立 =====
const ws = new WebSocket(url, {
    headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'OpenAI-Beta': 'realtime=v1'
    }
});

// ===== イベントバインディング =====
ws.on('open', () => {
    console.log('[WebSocket] サーバーに接続しました。');
    sendSessionUpdate();
    // 音声送信スレッドを開始
    sendAudio(localAudioPath);
});

ws.on('message', (message) => {
    try {
        const data = JSON.parse(message);
        console.log('[受信イベント]:', JSON.stringify(data, null, 2));

        // 最終認識結果は transcription.completed イベントにあります
        if (data.type === 'conversation.item.input_audio_transcription.completed') {
            console.log(`[最終文字起こし] ${data.transcript}`);
        }

        // finished イベントを受信
        if (data.type === 'session.finished') {
            console.log('[アクション] セッション完了後に WebSocket 接続を閉じています...');

            if (ws.readyState === WebSocket.OPEN) {
                ws.close(1000, 'ASR finished');
            }
        }
    } catch (e) {
        console.error('[エラー] メッセージの解析に失敗しました:', message);
    }
});

ws.on('close', (code, reason) => {
    console.log(`[WebSocket] 接続が閉じられました: ${code} - ${reason}`);
});

ws.on('error', (err) => {
    console.error('[WebSocket エラー]', err);
});

// ===== セッション更新 =====
function sendSessionUpdate() {
    const eventNoVad = {
        event_id: 'event_123',
        type: 'session.update',
        session: {
            modalities: ['text'],
            input_audio_format: 'pcm',
            sample_rate: 16000,
            // input_audio_transcription: {
            //     language: 'zh'
            // },
            turn_detection: null
        }
    };

    const eventVad = {
        event_id: 'event_123',
        type: 'session.update',
        session: {
            modalities: ['text'],
            input_audio_format: 'pcm',
            sample_rate: 16000,
            // input_audio_transcription: {
            //     language: 'zh'
            // },
            turn_detection: {
                type: 'server_vad',
                threshold: 0.0,
                silence_duration_ms: 400
            }
        }
    };

    if (enableServerVad) {
        console.log('[イベント送信] VAD モード:\n', JSON.stringify(eventVad, null, 2));
        ws.send(JSON.stringify(eventVad));
    } else {
        console.log('[イベント送信] マニュアルモード:\n', JSON.stringify(eventNoVad, null, 2));
        ws.send(JSON.stringify(eventNoVad));
    }
}

// ===== 音声ファイルストリームを送信 =====
function sendAudio(audioPath) {
    setTimeout(() => {
        console.log(`[ファイル読み取り開始] ${audioPath}`);
        const buffer = fs.readFileSync(audioPath);

        let offset = 0;
        const chunkSize = 3200; // 約 0.1s の PCM16 音声

        function sendChunk() {
            if (!isRunning) return;
            if (offset >= buffer.length) {
                isRunning = false; // 音声送信を停止
                console.log('[ファイル読み取り完了]');
                if (ws.readyState === WebSocket.OPEN) {
                    if (!enableServerVad) {
                        const commitEvent = {
                            event_id: 'event_789',
                            type: 'input_audio_buffer.commit'
                        };
                        ws.send(JSON.stringify(commitEvent));
                        console.log('[コミットイベント送信]');
                    }

                    const finishEvent = {
                        event_id: 'event_987',
                        type: 'session.finish'
                    };
                    ws.send(JSON.stringify(finishEvent));
                    console.log('[終了イベント送信]');
                }

                return;
            }

            if (ws.readyState !== WebSocket.OPEN) {
                console.log('[停止] WebSocket が開かれていません。');
                return;
            }

            const chunk = buffer.slice(offset, offset + chunkSize);
            offset += chunkSize;

            const encoded = chunk.toString('base64');
            const appendEvent = {
                event_id: `event_${Date.now()}`,
                type: 'input_audio_buffer.append',
                audio: encoded
            };

            ws.send(JSON.stringify(appendEvent));
            console.log(`[音声イベント送信] ${appendEvent.event_id}`);

            setTimeout(sendChunk, 100); // リアルタイム送信をシミュレート
        }

        sendChunk();
    }, 3000); // セッション設定の完了を待機
}

C#

サンプルコードは以下の通りです:

using System.Net.WebSockets;
using System.Text;
using System.Text.Json.Nodes;

class Program {
    private static ClientWebSocket _webSocket = new ClientWebSocket();
    private static CancellationTokenSource _cts = new CancellationTokenSource();
    private static bool _sessionFinished = false;
    private static bool _isRunning = true;

    // VAD モードを使用するかどうかを制御
    private const bool EnableServerVad = true;

    // API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
    // 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: private static readonly string ApiKey = "sk-xxx"
    private static readonly string ApiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY") ?? throw new InvalidOperationException("DASHSCOPE_API_KEY 環境変数が設定されていません。");
    private const string Model = "qwen3-asr-flash-realtime";
    // 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
    private const string BaseUrl = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime";
    private const string AudioFilePath = "your_audio_file.pcm"; // PCM 音声ファイルのパスに置き換えてください

    static async Task Main(string[] args) {
        var url = $"{BaseUrl}?model={Model}";
        Console.WriteLine($"サーバーに接続中: {url}");

        // 認証ヘッダーを設定
        _webSocket.Options.SetRequestHeader("Authorization", $"Bearer {ApiKey}");
        _webSocket.Options.SetRequestHeader("OpenAI-Beta", "realtime=v1");

        await _webSocket.ConnectAsync(new Uri(url), _cts.Token);
        Console.WriteLine("サーバーに接続しました。");

        // メッセージ受信タスクを開始
        var receiveTask = ReceiveMessagesAsync();

        // session.update 設定を送信
        await SendSessionUpdateAsync();

        // 音声ストリームを送信
        await SendAudioStreamAsync();

        // session.finished イベントを待機
        while (!_sessionFinished && !_cts.IsCancellationRequested) {
            await Task.Delay(100);
        }

        if (_webSocket.State == WebSocketState.Open) {
            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "ASR finished", _cts.Token);
        }
    }

    private static async Task SendAsync(string text) {
        var bytes = Encoding.UTF8.GetBytes(text);
        await _webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, _cts.Token);
    }

    // session.update イベントを送信
    private static async Task SendSessionUpdateAsync() {
        var session = new JsonObject {
            ["modalities"] = new JsonArray { "text" },
            ["input_audio_format"] = "pcm",
            ["sample_rate"] = 16000,
            // ["input_audio_transcription"] = new JsonObject { ["language"] = "zh" }
        };
        if (EnableServerVad) {
            session["turn_detection"] = new JsonObject {
                ["type"] = "server_vad",
                ["threshold"] = 0.0,
                ["silence_duration_ms"] = 400
            };
        } else {
            session["turn_detection"] = null;
        }
        var payload = new JsonObject {
            ["event_id"] = "event_123",
            ["type"] = "session.update",
            ["session"] = session
        };
        Console.WriteLine($"session.update を送信: {payload.ToJsonString()}");
        await SendAsync(payload.ToJsonString());
    }

    // 音声ストリームを送信 (100ms ごとに 1 つの PCM チャンクを送信)
    private static async Task SendAudioStreamAsync() {
        await Task.Delay(3000); // セッション設定の完了を待機
        const int chunkSize = 3200; // 16kHz 16bit モノラルで 100ms
        using var fs = new FileStream(AudioFilePath, FileMode.Open, FileAccess.Read);
        var buffer = new byte[chunkSize];
        int read;
        while (_isRunning && (read = await fs.ReadAsync(buffer, 0, chunkSize)) > 0) {
            if (_webSocket.State != WebSocketState.Open) break;
            string b64 = Convert.ToBase64String(buffer, 0, read);
            var append = new JsonObject {
                ["event_id"] = $"event_{DateTimeOffset.Now.ToUnixTimeMilliseconds()}",
                ["type"] = "input_audio_buffer.append",
                ["audio"] = b64
            };
            await SendAsync(append.ToJsonString());
            await Task.Delay(100);
        }
        Console.WriteLine("ファイル読み取り完了。");
        if (_webSocket.State == WebSocketState.Open) {
            if (!EnableServerVad) {
                var commit = new JsonObject {
                    ["event_id"] = "event_789",
                    ["type"] = "input_audio_buffer.commit"
                };
                await SendAsync(commit.ToJsonString());
            }
            var finish = new JsonObject {
                ["event_id"] = "event_987",
                ["type"] = "session.finish"
            };
            await SendAsync(finish.ToJsonString());
        }
    }

    // サーバー側イベントを受信して処理
    private static async Task ReceiveMessagesAsync() {
        var buffer = new byte[16384];
        var sb = new StringBuilder();
        while (_webSocket.State == WebSocketState.Open && !_cts.IsCancellationRequested) {
            try {
                var result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), _cts.Token);
                if (result.MessageType == WebSocketMessageType.Close) {
                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", _cts.Token);
                    break;
                }
                sb.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
                if (!result.EndOfMessage) continue;
                string text = sb.ToString();
                sb.Clear();
                var data = JsonNode.Parse(text);
                string? type = data?["type"]?.GetValue<string>();
                Console.WriteLine($"イベントを受信: {type}");
                if (type == "conversation.item.input_audio_transcription.completed") {
                    Console.WriteLine($"最終文字起こし: {data!["transcript"]}");
                } else if (type == "session.finished") {
                    Console.WriteLine("セッション完了、終了中...");
                    _sessionFinished = true;
                    _isRunning = false;
                    break;
                }
            } catch (Exception ex) {
                Console.WriteLine($"受信エラー: {ex.Message}");
                break;
            }
        }
    }
}

PHP

サンプルプロジェクトのディレクトリ構造は以下の通りです:

my-php-project/

├── composer.json

├── vendor/

└── index.php

composer.json の内容は以下の通りです。必要に応じて依存関係のバージョンを調整してください:

{
    "require": {
        "react/event-loop": "^1.3",
        "react/socket": "^1.11",
        "ratchet/pawl": "^0.4"
    }
}

index.php の内容は以下の通りです:

<?php

require __DIR__ . '/vendor/autoload.php';

use Ratchet\Client\Connector;
use React\EventLoop\Loop;
use React\Socket\Connector as SocketConnector;

// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
// 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: $api_key = "sk-xxx"
$api_key = getenv("DASHSCOPE_API_KEY");
$model = 'qwen3-asr-flash-realtime';
// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
$base_url = 'wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime';
$websocket_url = $base_url . '?model=' . $model;
$audio_file_path = 'your_audio_file.pcm'; // PCM 音声ファイルのパスに置き換えてください

// VAD モードを使用するかどうかを制御
$enable_server_vad = true;

$loop = Loop::get();
$socketConnector = new SocketConnector($loop, [
    'tls' => ['verify_peer' => false, 'verify_peer_name' => false],
]);
$connector = new Connector($loop, $socketConnector);

$headers = [
    'Authorization' => 'Bearer ' . $api_key,
    'OpenAI-Beta' => 'realtime=v1',
];

$is_running = true;

$connector($websocket_url, [], $headers)->then(function ($conn) use ($loop, $audio_file_path, $enable_server_vad, &$is_running) {
    echo "WebSocket サーバーに接続しました\n";

    // サーバー側イベントをリッスン
    $conn->on('message', function($msg) use ($conn, &$is_running) {
        $event = json_decode($msg, true);
        if (!isset($event['type'])) {
            return;
        }
        echo "イベントを受信: {$event['type']}\n";
        if ($event['type'] === 'conversation.item.input_audio_transcription.completed') {
            echo "最終文字起こし: {$event['transcript']}\n";
        } elseif ($event['type'] === 'session.finished') {
            echo "セッション完了、終了中...\n";
            $is_running = false;
            $conn->close();
        }
    });
    $conn->on('close', function() {
        echo "接続が閉じられました\n";
    });

    // session.update イベントを送信
    sendSessionUpdate($conn, $enable_server_vad);

    // セッション設定完了後に音声送信を開始
    $loop->addTimer(3, function () use ($conn, $audio_file_path, $enable_server_vad, $loop, &$is_running) {
        sendAudioStream($conn, $audio_file_path, $enable_server_vad, $loop, $is_running);
    });
}, function ($e) {
    echo "接続できません: {$e->getMessage()}\n";
});

$loop->run();

// session.update イベントを送信
function sendSessionUpdate($conn, $enable_server_vad) {
    $session = [
        'modalities' => ['text'],
        'input_audio_format' => 'pcm',
        'sample_rate' => 16000,
        // 'input_audio_transcription' => ['language' => 'zh'],
        'turn_detection' => $enable_server_vad ? [
            'type' => 'server_vad',
            'threshold' => 0.0,
            'silence_duration_ms' => 400,
        ] : null,
    ];
    $event = [
        'event_id' => 'event_123',
        'type' => 'session.update',
        'session' => $session,
    ];
    $conn->send(json_encode($event));
    echo "session.update を送信しました\n";
}

// 音声ストリームを送信 (100ms ごとに 1 つの PCM チャンクを送信)
function sendAudioStream($conn, $audio_file_path, $enable_server_vad, $loop, &$is_running) {
    $fp = fopen($audio_file_path, 'rb');
    if (!$fp) {
        echo "音声ファイルを開けません\n";
        return;
    }
    $send_chunk = function() use ($conn, $fp, $enable_server_vad, $loop, &$send_chunk, &$is_running) {
        if (!$is_running) {
            fclose($fp);
            return;
        }
        $chunk = fread($fp, 3200); // 16kHz 16bit モノラルで 100ms
        if ($chunk === false || strlen($chunk) === 0) {
            fclose($fp);
            echo "音声ストリーム終了\n";
            if (!$enable_server_vad) {
                $conn->send(json_encode([
                    'event_id' => 'event_789',
                    'type' => 'input_audio_buffer.commit',
                ]));
            }
            $conn->send(json_encode([
                'event_id' => 'event_987',
                'type' => 'session.finish',
            ]));
            return;
        }
        $append = [
            'event_id' => 'event_' . round(microtime(true) * 1000),
            'type' => 'input_audio_buffer.append',
            'audio' => base64_encode($chunk),
        ];
        $conn->send(json_encode($append));
        $loop->addTimer(0.1, $send_chunk);
    };
    $send_chunk();
}

Go

例を実行する前に、必要な依存関係をインストールしてください:

go get github.com/gorilla/websocket

package main

import (
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	"github.com/gorilla/websocket"
)

const (
	// 以下はシンガポールリージョンの設定です。呼び出し時に "{WorkspaceId}" を実際のワークスペース ID に置き換えてください。リージョンによって設定が異なります。
	baseURL         = "wss://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api-ws/v1/realtime"
	model           = "qwen3-asr-flash-realtime"
	audioFile       = "your_audio_file.pcm" // PCM 音声ファイルのパスに置き換えてください
	enableServerVad = true                  // VAD モードを使用するかどうかを制御
)

// サーバー側イベント構造体
type ServerEvent struct {
	Type       string `json:"type"`
	Transcript string `json:"transcript,omitempty"`
}

func main() {
	// API キーはシンガポールリージョンと北京リージョンで異なります。API キーの取得: https://www.alibabacloud.com/help/zh/model-studio/get-api-key
	// 環境変数を設定していない場合は、次の行を Alibaba Cloud Model Studio API キーに置き換えてください: apiKey := "sk-xxx"
	apiKey := os.Getenv("DASHSCOPE_API_KEY")

	url := baseURL + "?model=" + model
	log.Printf("サーバーに接続中: %s", url)

	conn, err := connect(url, apiKey)
	if err != nil {
		log.Fatal("WebSocket への接続に失敗しました: ", err)
	}
	defer conn.Close()

	// メッセージを受信するゴルーチンを開始
	sessionFinished := make(chan bool, 1)
	go receiveMessages(conn, sessionFinished)

	// session.update を送信
	if err := sendSessionUpdate(conn); err != nil {
		log.Fatal("session.update の送信に失敗しました: ", err)
	}

	// セッション設定の完了を待機
	time.Sleep(3 * time.Second)

	// 音声ストリームを送信
	if err := sendAudioStream(conn); err != nil {
		log.Fatal("音声の送信に失敗しました: ", err)
	}

	// session.finished を待機
	<-sessionFinished
}

// WebSocket 接続を確立
func connect(url, apiKey string) (*websocket.Conn, error) {
	headers := http.Header{}
	headers.Set("Authorization", "Bearer "+apiKey)
	headers.Set("OpenAI-Beta", "realtime=v1")
	conn, _, err := websocket.DefaultDialer.Dial(url, headers)
	return conn, err
}

// session.update イベントを送信
func sendSessionUpdate(conn *websocket.Conn) error {
	session := map[string]interface{}{
		"modalities":         []string{"text"},
		"input_audio_format": "pcm",
		"sample_rate":        16000,
		// "input_audio_transcription": map[string]interface{}{
		// 	"language": "zh",
		// },
	}
	if enableServerVad {
		session["turn_detection"] = map[string]interface{}{
			"type":                "server_vad",
			"threshold":           0.0,
			"silence_duration_ms": 400,
		}
	} else {
		session["turn_detection"] = nil
	}
	event := map[string]interface{}{
		"event_id": "event_123",
		"type":     "session.update",
		"session":  session,
	}
	payload, _ := json.Marshal(event)
	log.Printf("session.update を送信: %s", string(payload))
	return conn.WriteMessage(websocket.TextMessage, payload)
}

// 音声ストリームを送信 (100ms ごとに 1 つの PCM チャンクを送信)
func sendAudioStream(conn *websocket.Conn) error {
	f, err := os.Open(audioFile)
	if err != nil {
		return err
	}
	defer f.Close()

	chunk := make([]byte, 3200) // 16kHz 16bit モノラルで 100ms
	for {
		n, err := f.Read(chunk)
		if n > 0 {
			event := map[string]interface{}{
				"event_id": fmt.Sprintf("event_%d", time.Now().UnixMilli()),
				"type":     "input_audio_buffer.append",
				"audio":    base64.StdEncoding.EncodeToString(chunk[:n]),
			}
			payload, _ := json.Marshal(event)
			if err := conn.WriteMessage(websocket.TextMessage, payload); err != nil {
				return err
			}
			time.Sleep(100 * time.Millisecond)
		}
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
	}
	log.Println("音声ストリーム終了")
	if !enableServerVad {
		commitEvt := map[string]interface{}{
			"event_id": "event_789",
			"type":     "input_audio_buffer.commit",
		}
		payload, _ := json.Marshal(commitEvt)
		if err := conn.WriteMessage(websocket.TextMessage, payload); err != nil {
			return err
		}
	}
	finishEvt := map[string]interface{}{
		"event_id": "event_987",
		"type":     "session.finish",
	}
	payload, _ := json.Marshal(finishEvt)
	return conn.WriteMessage(websocket.TextMessage, payload)
}

// サーバー側イベントを受信して処理
func receiveMessages(conn *websocket.Conn, sessionFinished chan<- bool) {
	for {
		_, msg, err := conn.ReadMessage()
		if err != nil {
			log.Println("メッセージの読み取りエラー: ", err)
			sessionFinished <- true
			return
		}
		var evt ServerEvent
		if err := json.Unmarshal(msg, &evt); err != nil {
			log.Println("メッセージの解析エラー: ", err)
			continue
		}
		log.Printf("イベントを受信: %s", evt.Type)
		switch evt.Type {
		case "conversation.item.input_audio_transcription.completed":
			log.Printf("最終文字起こし: %s", evt.Transcript)
		case "session.finished":
			log.Println("セッション完了")
			sessionFinished <- true
			return
		}
	}
}