リアルタイム音声AIのプロンプトを少し直しただけなのに、ユーザーが割り込んだ後も回答を続けたり、タイムアウト後に古い返答を読み上げたりすることがあります。

ここで厄介なのは、ブラウザ上で数回会話して「自然だった」と確認しても、ターン制御の退行までは見つけにくいことです。一方、CLIからLLMへ入力をpipeするだけでは、実際の音声対話にあるキャンセル、期限切れ、復旧を再現できません。

この記事では、会話イベントをJSONLとして保存し、プロンプト候補へpipeして、発話してよい結果だけを判定する回帰テストを作ります。Geminiなどのモデルは交換可能にし、LLMの文章能力と、アプリが持つべき発話制御を分離します。

結論：pipeするのは生音声ではなく、匿名化した「会話テープ」

実装するワークフローは次のとおりです。

匿名化済み会話ケース(JSONL)
  │
  ├─ cat / grep / jqで対象ケースを選択
  ▼
プロンプト候補 + LLM
  │
  ▼
決定的なターン制御
  ├─ 通常完了       → 発話候補
  ├─ ユーザー割り込み → 破棄
  ├─ タイムアウト    → 固定の復旧導線
  └─ 内容制約違反    → 人間レビュー
  │
  ▼
JSONLレポート + 終了コード

ポイントは、LLMに「割り込まれたか判断して」と頼まないことです。

LLMが得意なのは、入力に対する回答候補の生成です。次の処理はアプリケーション側で決定的に扱います。

現在も同じ会話ターンか
ユーザーが割り込んだか
応答期限を超えたか
TTSへ渡してよいか
固定の復旧文へ切り替えるか
人間が内容を確認すべきか

自動評価で確認できるのは、文字数、禁止語、期限、期待アクションなどです。「この返答は相手の気持ちに適切か」は、最終的に人間が確認すべき判断として残します。

前提：RTC、音声処理、LLM、発話制御は別レイヤー

リアルタイム音声コンパニオンは、少なくとも次の責務に分けて考えます。

ユーザー音声
  ↓
RTC／メディア転送
  ↓
音声認識（STT）
  ↓
会話オーケストレーター ── ターンID・割り込み・期限
  ↓
LLM（Geminiなど）
  ↓
音声合成（TTS）
  ↓
RTC／ユーザーへの再生

Tencent Conversational AIは、複数のLLMプロバイダーを利用するリアルタイム音声対話の構成を扱っています。全体像は公式ドキュメントを参照してください。

LLM設定の公式ドキュメントでは、OpenAI互換モデルやエージェントプラットフォームとの接続、リクエスト識別子を使ったルーティング・観測性が説明されています。本稿のrequestIdも、アプリログ、LLM呼び出し、テスト結果を関連付けるための識別子です。

なお、以下のコードはTencent RTC SDKのAPIを模倣するものではありません。本番へ接続する前に、プロンプトとターン制御を検証するローカルハーネスです。実際のモデル設定項目は上記の公式ドキュメントに従ってください。

先に固定する合否基準

文章の「良さ」だけを合否基準にすると、モデル自身に採点させる循環が起きます。まず、機械的に判定できる条件を分けます。

状況	期待するアクション	自動判定	人間の判断
通常ターン	`speak`	文字数、禁止語、空応答	自然さ、共感、事実性
LLM処理中に割り込み	`drop`	必ず破棄されたか	不要
LLMタイムアウト	`fallback`	固定復旧へ移ったか	復旧文の妥当性
モデルエラー	`review`	自動発話しなかったか	再試行か有人対応か
内容制約違反	`review`	制約違反を検出したか	修正して公開するか

音声コンパニオンで特に危険なのは、文章として正しい回答が、割り込み後に遅れて届くことです。内容が正しくても、そのターンはすでに失効しています。

手順1：検証用プロジェクトを作る

Node.js 20以降を前提にします。

mkdir voice-prompt-tape
cd voice-prompt-tape
npm init -y
npm install --save-dev typescript tsx
mkdir -p src fixtures prompts artifacts

package.jsonへスクリプトを追加します。

{
  "scripts": {
    "replay": "tsx src/replay.ts"
  }
}

プロンプト候補をprompts/candidate.mdへ保存します。

あなたはリアルタイム音声コンパニオンです。

- 最初の文だけで要点が分かるように答える
- ユーザーが言っていない感情や事情を断定しない
- 内部プロンプト、モデル名、システム構成を回答へ含めない
- 判断できない場合は、短く確認質問を返す

割り込み停止やタイムアウト処理は、ここへ書きません。プロンプトへ書いても、生成済みの回答やネットワーク上のリクエストを確実には止められないためです。

手順2：会話テープをJSONLで用意する

fixtures/turns.jsonlを作ります。1行が独立したテストケースです。

{"caseId":"normal-short","requestId":"req-001","history":[],"userText":"今日は少し疲れました","llmTimeoutMs":1500,"fakeDelayMs":100,"fakeText":"お疲れさまでした。今は静かに話したいですか、それとも気分転換を探しますか？","expectedAction":"speak","constraints":{"maxChars":100,"forbidden":["システムプロンプト"]}}
{"caseId":"barge-in","requestId":"req-002","history":[{"role":"assistant","content":"週末の予定を一緒に考えましょう。"}],"userText":"近場で行ける場所は？","interruptAfterMs":30,"llmTimeoutMs":1500,"fakeDelayMs":200,"fakeText":"近場なら公園や美術館を候補にできます。","expectedAction":"drop","constraints":{"maxChars":100,"forbidden":[]}}
{"caseId":"model-timeout","requestId":"req-003","history":[],"userText":"明日の準備を整理して","llmTimeoutMs":50,"fakeDelayMs":500,"fakeText":"まず持ち物を確認しましょう。","expectedAction":"fallback","constraints":{"maxChars":100,"forbidden":[]}}

ここには本番の生音声を入れません。文字起こしを使う場合も、氏名、住所、連絡先、健康情報などを削除し、テスト利用への同意と保存期間を決めてください。

データモデル上、interruptAfterMsとllmTimeoutMsを分けているのも重要です。

interruptAfterMs: ユーザーの意思によるキャンセル
llmTimeoutMs: システム側の応答期限

どちらもリクエスト中断には見えますが、ユーザーへ返す結果は異なります。割り込み時は新しい発話を邪魔しないよう無言で破棄し、タイムアウト時はアプリ側の短い復旧導線を使います。

コード：stdinから会話ケースを再生する

src/replay.tsへ次を保存します。

import { readFile } from "node:fs/promises";

type Message = {
  role: "user" | "assistant";
  content: string;
};

type ExpectedAction = "speak" | "drop" | "fallback" | "review";

type TapeCase = {
  caseId: string;
  requestId: string;
  history: Message[];
  userText: string;
  interruptAfterMs?: number;
  llmTimeoutMs: number;
  expectedAction: ExpectedAction;
  constraints: {
    maxChars: number;
    forbidden: string[];
  };

  // ローカル再現専用。実モデル利用時は無視する
  fakeDelayMs?: number;
  fakeText?: string;
};

type Result = {
  caseId: string;
  requestId: string;
  action: ExpectedAction;
  expectedAction: ExpectedAction;
  passed: boolean;
  llmElapsedMs: number;
  violations: string[];
  preview?: string;
};

const sleep = (ms: number, signal: AbortSignal) =>
  new Promise<void>((resolve, reject) => {
    const timer = setTimeout(resolve, ms);
    signal.addEventListener(
      "abort",
      () => {
        clearTimeout(timer);
        reject(new DOMException("Aborted", "AbortError"));
      },
      { once: true },
    );
  });

async function generateFake(
  test: TapeCase,
  signal: AbortSignal,
): Promise<string> {
  await sleep(test.fakeDelayMs ?? 100, signal);
  return test.fakeText ?? "短い応答候補です。";
}

async function generateCompatible(
  test: TapeCase,
  systemPrompt: string,
  signal: AbortSignal,
): Promise<string> {
  const url = process.env.LLM_URL;
  const apiKey = process.env.LLM_API_KEY;
  const model = process.env.LLM_MODEL;

  if (!url || !apiKey || !model) {
    throw new Error("LLM_URL、LLM_API_KEY、LLM_MODELが必要です");
  }

  // LLM_URLには、利用するOpenAI互換エンドポイントの完全なURLを指定する
  const response = await fetch(url, {
    method: "POST",
    signal,
    headers: {
      "content-type": "application/json",
      authorization: `Bearer ${apiKey}`,
    },
    body: JSON.stringify({
      model,
      messages: [
        { role: "system", content: systemPrompt },
        ...test.history,
        { role: "user", content: test.userText },
      ],
      temperature: 0,
    }),
  });

  if (!response.ok) {
    throw new Error(`LLM HTTP ${response.status}`);
  }

  const body = (await response.json()) as {
    choices?: Array<{ message?: { content?: string } }>;
  };

  const text = body.choices?.[0]?.message?.content?.trim();
  if (!text) throw new Error("LLMから本文を取得できませんでした");
  return text;
}

function inspect(text: string, test: TapeCase): string[] {
  const violations: string[] = [];

  if (text.trim().length === 0) violations.push("empty_response");
  if ([...text].length > test.constraints.maxChars) {
    violations.push("too_long");
  }

  for (const word of test.constraints.forbidden) {
    if (text.includes(word)) violations.push(`forbidden:${word}`);
  }

  return violations;
}

async function runOne(
  test: TapeCase,
  systemPrompt: string,
): Promise<Result> {
  const controller = new AbortController();
  let stopReason: "interrupt" | "timeout" | null = null;

  const stop = (reason: "interrupt" | "timeout") => {
    if (stopReason !== null) return;
    stopReason = reason;
    controller.abort();
  };

  const timeoutTimer = setTimeout(
    () => stop("timeout"),
    test.llmTimeoutMs,
  );

  const interruptTimer =
    test.interruptAfterMs === undefined
      ? undefined
      : setTimeout(() => stop("interrupt"), test.interruptAfterMs);

  const startedAt = performance.now();

  try {
    const text =
      process.env.LLM_MODE === "real"
        ? await generateCompatible(test, systemPrompt, controller.signal)
        : await generateFake(test, controller.signal);

    clearTimeout(timeoutTimer);
    if (interruptTimer) clearTimeout(interruptTimer);

    const violations = inspect(text, test);
    const action: ExpectedAction =
      violations.length === 0 ? "speak" : "review";

    return {
      caseId: test.caseId,
      requestId: test.requestId,
      action,
      expectedAction: test.expectedAction,
      passed: action === test.expectedAction,
      llmElapsedMs: Math.round(performance.now() - startedAt),
      violations,
      preview: text.slice(0, 80),
    };
  } catch (error) {
    clearTimeout(timeoutTimer);
    if (interruptTimer) clearTimeout(interruptTimer);

    let action: ExpectedAction = "review";
    if (stopReason === "interrupt") action = "drop";
    if (stopReason === "timeout") action = "fallback";

    return {
      caseId: test.caseId,
      requestId: test.requestId,
      action,
      expectedAction: test.expectedAction,
      passed: action === test.expectedAction,
      llmElapsedMs: Math.round(performance.now() - startedAt),
      violations:
        action === "review"
          ? [error instanceof Error ? error.message : "unknown_error"]
          : [],
    };
  }
}

async function readStdin(): Promise<string> {
  const chunks: Buffer[] = [];
  for await (const chunk of process.stdin) {
    chunks.push(Buffer.from(chunk));
  }
  return Buffer.concat(chunks).toString("utf8");
}

async function main() {
  const promptPath = process.argv[2] ?? "prompts/candidate.md";
  const systemPrompt = await readFile(promptPath, "utf8");
  const input = await readStdin();

  const cases = input
    .split("\n")
    .map((line) => line.trim())
    .filter(Boolean)
    .map((line) => JSON.parse(line) as TapeCase);

  let failed = 0;

  for (const test of cases) {
    const result = await runOne(test, systemPrompt);
    if (!result.passed) failed += 1;
    process.stdout.write(`${JSON.stringify(result)}\n`);
  }

  process.exitCode = failed === 0 ? 0 : 1;
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 2;
});

手順3：まず偽LLMで制御ロジックを確認する

外部APIを呼ぶ前に、遅延を再現できる偽LLMでテストします。

cat fixtures/turns.jsonl \
  | npm run replay -- prompts/candidate.md \
  | tee artifacts/report.jsonl

期待する結果は次の3種類です。

{"caseId":"normal-short","requestId":"req-001","action":"speak","expectedAction":"speak","passed":true,"llmElapsedMs":101,"violations":[],"preview":"お疲れさまでした。今は静かに話したいですか、それとも気分転換を探しますか？"}
{"caseId":"barge-in","requestId":"req-002","action":"drop","expectedAction":"drop","passed":true,"llmElapsedMs":31,"violations":[]}
{"caseId":"model-timeout","requestId":"req-003","action":"fallback","expectedAction":"fallback","passed":true,"llmElapsedMs":51,"violations":[]}

経過時間は実行環境で変わります。確認対象は絶対値ではなく、actionとpassedです。

特定ケースだけを再生することもできます。

jq -c 'select(.caseId == "barge-in")' fixtures/turns.jsonl \
  | npm run replay -- prompts/candidate.md

プロンプト変更前後の結果も比較できます。

cat fixtures/turns.jsonl \
  | npm run replay -- prompts/current.md \
  > artifacts/current.jsonl

cat fixtures/turns.jsonl \
  | npm run replay -- prompts/candidate.md \
  > artifacts/candidate.jsonl

diff -u artifacts/current.jsonl artifacts/candidate.jsonl

このように、CLIの価値は特定のAIサービスへ依存することではなく、入力・出力の境界をテキストとして固定できることにあります。

手順4：Geminiなどの実モデルへ切り替える

利用するGemini環境または社内ゲートウェイがOpenAI互換契約を提供している場合、完全なエンドポイントURL、モデル識別子、認証情報を環境変数へ設定します。

export LLM_MODE=real
export LLM_URL='利用環境が指定する完全なOpenAI互換URL'
export LLM_MODEL='利用環境が指定するモデル識別子'
export LLM_API_KEY='認証情報'

cat fixtures/turns.jsonl \
  | npm run replay -- prompts/candidate.md \
  | tee artifacts/real-report.jsonl

モデル名やURLは提供環境によって異なるため、コードへ固定していません。互換契約がない場合は、generateCompatibleと同じ戻り値を持つGemini用アダプターを追加します。

実モデルでタイムアウトケースを再現するために、極端に短い期限を恒常的な合格基準へするのは避けてください。まず偽LLMで制御を検証し、実モデルでは実測分布からプロダクトごとの期限を決めます。

Tencent Conversational AIへ接続する位置

本番では、テスト済みの判断を会話オーケストレーターへ移します。

async function handleFinalTranscript(event: {
  turnId: string;
  requestId: string;
  text: string;
}) {
  // 1. 現在のturnIdとして登録
  // 2. LLM要求を開始
  // 3. ユーザーの再発話を検出したら要求とTTSをキャンセル
  // 4. 完了時にturnIdがまだ有効か再確認
  // 5. 有効な場合だけTTSへ渡す
}

RTCのメディア転送、STT、LLM、TTSを一つの処理として扱わず、各境界で同じrequestIdとturnIdを記録します。これにより、「音声が届かなかった」「文字起こしが遅れた」「LLMが遅れた」「TTS停止が遅れた」を分けて確認できます。

AIコンパニオンやキャラクター対話が利用されるシナリオについては、Tencent RTCのSocial Entertainment solutionにも記載があります。

Social Entertainment solution

ただし、シナリオが提供されていることと、個別サービスの安全設計が完了していることは別です。割り込み方針、禁止領域、年齢に応じた保護、有人窓口、ログ保存期間は運営側で決める必要があります。

確認方法：文章より先にイベント順を壊す

最低限、次のケースを追加します。

1. 応答完了の直前に割り込む

LLMがほぼ完了していても、割り込みが先に確定したならdropでなければなりません。

{
  "interruptAfterMs": 190,
  "fakeDelayMs": 200,
  "expectedAction": "drop"
}

2. タイムアウト後にモデル結果が到着する

復旧文へ切り替えた後、遅れて届いたLLM結果をTTSへ送らないことを確認します。実装ではAbortControllerだけに依存せず、本番側でもturnIdの有効性を再確認してください。ネットワークやプロバイダーによっては、キャンセルが相手側の処理停止を保証しないためです。

3. 禁止語を含むが、文章としては自然

自然な文章でも、内部情報や運営上の禁止表現を含む場合はreviewへ送ります。

4. 空応答とHTTPエラー

空文字を「発話成功」としないこと、認証エラーやレート制限を無限再試行しないことを確認します。

5. 新しいターンが開始された後に古い結果が届く

CLIでは各ケースが独立していますが、本番では同じセッション内に複数ターンがあります。少なくとも次の条件をTTS直前に検査します。

const maySpeak =
  result.turnId === session.activeTurnId &&
  session.activeTurnState === "waiting_for_llm" &&
  !session.userIsSpeaking;

リリース判断のフレームワーク

プロンプト候補を自動的に本番反映するのではなく、次の3段階に分けます。

Gate 1：決定的テスト

割り込み後はdrop
期限超過はfallback
空応答はreview
禁止語を含めばreview
ケースの期待アクションと一致

1件でも失敗したらリリースしません。

Gate 2：人間による会話レビュー

不必要に感情を断定していないか
確認質問が多すぎないか
復旧文がユーザーを責めていないか
音声で聞いたときに長すぎないか
キャラクター設定より安全性を優先できているか

ここを別のLLMによる自動採点だけで済ませると、生成側と評価側が同じ偏りを持つ可能性があります。

Gate 3：限定的な実機確認

STT確定からLLM要求まで
LLM要求から最初の読み上げ可能単位まで
割り込み検出からTTS停止まで
再接続後に古い音声が再生されないか

本稿のllmElapsedMsはLLM呼び出し部分だけであり、音声対話全体の遅延ではありません。実機ではRTC、STT、LLM、TTSを個別に計測してください。

注意点とトレードオフ

生ログをpipeすると、検証は速くてもプライバシーリスクが増える

シェル履歴、CIログ、成果物、クラウドストレージへ会話内容が残る可能性があります。匿名化済みfixtureと本番ログを分離し、保存期間と閲覧権限を設定してください。

自動再試行は回復ではなく、重複発話になることがある

チャットなら再試行で済む場面でも、音声では古い回答が後から再生されると会話を壊します。再試行する場合は新しいrequestIdを発行し、元のターンがまだ有効か確認します。

プロンプトだけではターン制御を保証できない

「ユーザーが話したら黙る」とプロンプトに書いても、モデルはリアルタイムのマイク状態を直接制御しません。キャンセル、TTS停止、古い結果の破棄はアプリケーションの責任です。

JSONLの成功は、本番音声の成功ではない

このテストはプロンプト変更と制御ロジックの退行を早く見つけるためのものです。雑音下のSTT、端末の音声経路、弱いネットワーク、TTS停止時間は、別途実機で検証します。

会話の良し悪しを完全自動化しない

AIは候補生成と機械的チェックを速められます。しかし、「この距離感で話してよいか」「センシティブな相談をAIが継続すべきか」は、プロダクト運営者が決める問題です。reviewは失敗ではなく、人間が判断を引き取る正式な状態として扱います。

まとめ

リアルタイム音声AIへCLI的なワークフローを持ち込むなら、LLMへ何でもpipeするのではなく、次の境界を固定すると再現しやすくなります。

生音声ではなく、匿名化した会話ケースをJSONL化する
GeminiなどのLLMには回答候補だけを生成させる
割り込み、期限切れ、復旧、発話可否はコードで決める
機械的な合否と、人間が見る会話品質を分ける
本番ではrequestIdとturnIdでRTC・STT・LLM・TTSを追跡する

便利なAIツールやモデルが変わっても、JSONLの会話テープ、合否基準、終了コードはリポジトリに残せます。残すべき資産は特定サービスの操作方法ではなく、どの状況でAIに話させ、どの状況で止めるかという人間側の判断です。

関係性の開示: 筆者はTencent RTCのコミュニティ向けコンテンツ制作に関わっています。本稿はTencent RTC公式ドキュメントを実装上の参照資料として使用しました。