ストリーミングによる高速化

async def extract_speech_gate(input_message, output_message):
    """
    【xxx】yyy (zzz) から yyy を取り出す（非ストリーミング版）

    入力例: "【嬉しい】こんにちは、元気ですか？ (本当は眠い)"
    出力例: "こんにちは、元気ですか？"
    """
    # import re <- 独自importは禁止。大体のライブラリはすでにimport済み

    # gate モードなので、この時点で完全なデータが揃っている
    text = input_message.values.response.x

    # 【xxx】を除去
    text = re.sub(r'【[^】]*】', '', text)

    # (zzz) を除去
    text = re.sub(r'\s*[（(][^）)]*[）)]', '', text)

    # 前後の空白を除去
    result = text.strip()

    # 結果を出力（一度だけなので is_last=True）
    await output_message.update('response', result, is_last=True)

async def extract_speech_realtime(input_message, output_message):
    """
    【xxx】yyy (zzz) から yyy を取り出す（ストリーミング版）

    入力の流れ:
      "【嬉し"                    → Continue()（【】が閉じていない）
      "【嬉しい】"                → Continue()（本文がまだない）
      "【嬉しい】こんにちは"       → "こんにちは" を出力 (is_last=False)
      "【嬉しい】こんにちは (本当" → "こんにちは" を出力 (is_last=True) + Break()
      （以降は処理されない）

    ポイント: (が出現したら、その前までを出力してループ終了
    """
    # import re <- 独自importは禁止。大体のライブラリはすでにimport済み

    text = input_message.values.response.x
    is_last = input_message.is_last('response')

    # --- 【】の処理 ---
    # 【が開いているが】が閉じていない場合は待機
    if '【' in text and '】' not in text:
        return Continue()

    # 【xxx】を除去
    text_without_bracket = re.sub(r'【[^】]*】', '', text)

    # 本文がまだない場合は待機
    if not text_without_bracket.strip():
        return Continue()

    # --- ()の処理 ---
    # (または（が出現したら、その前までを出力して早期終了
    if '(' in text_without_bracket or '（' in text_without_bracket:
        # (以前の部分を抽出
        result = re.split(r'[（(]', text_without_bracket)[0]
        await output_message.update('response', result.strip(), is_last=True)
        return Break()  # ループを終了

    # 括弧がない場合は通常出力
    await output_message.update('response', text_without_bracket.strip(), is_last=is_last)

async def my_func(input_message, output_message):
    # buffer は realtime モードで自動的に提供される辞書
    # 初回呼び出し時に初期化
    if 'count' not in buffer:
        buffer['count'] = 0
        buffer['prev_text'] = ""

    # 状態を更新
    buffer['count'] += 1

    # 処理...

async def output_diff(input_message, output_message):
    """
    前回からの差分（新しく追加された文字）だけを出力する

    入力の流れ:
      "こん"           → "こん" を出力
      "こんにち"       → "にち" を出力（差分）
      "こんにちは"     → "は" を出力（差分）
    """
    text = input_message.values.response.x
    is_last = input_message.is_last('response')

    # 前回のテキストを保持
    if 'prev_text' not in buffer:
        buffer['prev_text'] = ""

    # 差分を計算
    diff = text[len(buffer['prev_text']):]
    buffer['prev_text'] = text

    # 差分がある場合のみ出力
    if diff:
        await output_message.update('response', diff, is_last=is_last)

    # 終了時にリセット
    if is_last:
        buffer['prev_text'] = ""

async def extract_speech(input_message, output_message):
    """
    【aa】bb (cc) から bb を取り出す
    """
    import re

    text = input_message.values.response.x
    is_last = input_message.is_last('response')

    # 【】が閉じていない場合は待機
    if '【' in text and '】' not in text:
        return Continue()

    # 【aa】を除去
    text = re.sub(r'【[^】]*】', '', text)

    # (が来たら、その前までを出力してループ終了
    if '(' in text or '（' in text:
        text = re.split(r'[（(]', text)[0]
        await output_message.update('response', text.strip(), is_last=True)
        return Break()

    await output_message.update('response', text.strip(), is_last=is_last)

async def parse_emotion_text(input_message, output_message):
    """
    【aa】bb (cc) を aa, bb, cc に分離する

    送信タイミング:
      - emotion: 【】が閉じたら確定送信
      - text: (が来たら確定送信（それまではストリーミング）
      - thought: ()が閉じたら確定送信
    """
    import re

    input_text = input_message.values.response.x
    is_last = input_message.is_last('response')

    # --- buffer初期化 ---
    if 'emotion_sent' not in buffer:
        buffer['emotion_sent'] = False
        buffer['text_sent'] = False
        buffer['thought_sent'] = False
        buffer['emotion'] = ""
        buffer['thought'] = ""

    # --- 【】が閉じていない場合は待機 ---
    if '【' in input_text and '】' not in input_text:
        return Continue()

    # --- 感情の抽出と送信 ---
    match = re.search(r'【(.+?)】', input_text)
    if match:
        buffer['emotion'] = match.group(1)

    # emotionは一度だけis_last=Trueで送信
    if not buffer['emotion_sent']:
        await output_message.update('emotion', buffer['emotion'], is_last=True)
        buffer['emotion_sent'] = True

    # --- 【aa】を除去した残り ---
    remaining = re.sub(r'【[^】]*】', '', input_text)

    # --- 括弧の有無を確認 ---
    has_open_paren = '(' in remaining or '（' in remaining
    open_count = remaining.count('(') + remaining.count('（')
    close_count = remaining.count(')') + remaining.count('）')
    paren_closed = open_count > 0 and open_count == close_count

    # --- 発話部分（(の前）を抽出 ---
    if has_open_paren:
        text_content = re.split(r'[（(]', remaining)[0].strip()
    else:
        text_content = remaining.strip()

    # --- textの送信 ---
    if not buffer['text_sent']:
        if has_open_paren:
            # (が来たらtextを確定送信
            if text_content:
                await output_message.update('text', text_content, is_last=True)
            buffer['text_sent'] = True
        elif text_content:
            # (がまだ来ていない場合はストリーミング送信
            await output_message.update('text', text_content, is_last=False)

    # --- 心の声の抽出と送信 ---
    if paren_closed and not buffer['thought_sent']:
        thought_match = re.search(r'[（(](.+?)[）)]', remaining)
        buffer['thought'] = thought_match.group(1) if thought_match else ""
        await output_message.update('thought', buffer['thought'], is_last=True)
        buffer['thought_sent'] = True

    # --- ()が閉じていない場合は待機 ---
    if has_open_paren and not paren_closed:
        return Continue()

    # --- DialogAdd用のmeta（is_last=Trueのときのみ意味がある）---
    if is_last:
        await output_message.update('meta', {
            'emotion': buffer['emotion'],
            'thought': buffer['thought']
        }, is_last=True)
        # bufferリセット
        buffer['emotion_sent'] = False
        buffer['text_sent'] = False
        buffer['thought_sent'] = False
        buffer['emotion'] = ""
        buffer['thought'] = ""

async def extract_decoration_id(input_message, output_message):
    """
    セリフから [emotion:xxx] を抽出し、テキストと decoration_id を分離する

    入力例: "[emotion:laughing_speech]ハッハー！「よろー」だって！？"
    出力:
      - decoration_id: "laughing_speech" (is_last=True)
      - response: "ハッハー！「よろー」だって！？" (streaming)
    """
    text = input_message.values.response.x
    is_last = input_message.is_last('response')

    # --- タグが閉じていない場合は待機 ---
    if '[' in text and ']' not in text:
        return Continue()

    # --- buffer初期化 ---
    if 'decoration_id_sent' not in buffer:
        buffer['decoration_id_sent'] = False
        buffer['decoration_id'] = 'neutral'  # デフォルト値

    # --- decoration_id の抽出（一度だけ送信）---
    match = re.search(r'\[(?:emotion|decoration_id):([^\]]+)\]', text)
    if match and not buffer['decoration_id_sent']:
        buffer['decoration_id'] = match.group(1).strip()
        # ★ decoration_idを先に確定送信（TTS3がこれを待つ）
        await output_message.update('decoration_id', buffer['decoration_id'], is_last=True)
        buffer['decoration_id_sent'] = True

    # タグを除去してテキストを取得
    clean_text = re.sub(r'\[[^\]]*\]', '', text).strip()

    # テキストがまだない場合は待機
    if not clean_text:
        return Continue()

    # ★ responseをストリーミング送信（TTS3はdecoration_id確定後に処理開始）
    await output_message.update('response', clean_text, is_last=is_last)