AiTuber開発日誌 8 会話が続くようにする。

1. PCが固まる（CPU暴走）

対策: コメントがない時に await asyncio.sleep() で「休憩」を入れます。これを入れないと、プログラムが全速力で「コメントまだ？まだ？まだ？」と確認し続けてPCが重くなります。

2. エラーで即死する

対策: ネットが一瞬切れたり、APIがエラーを返したりしただけで止まらないよう、try-except でエラーを無視してループを続けるようにします

3. 記憶があふれる

対策: 会話履歴（history）が無限に増えると、AIの記憶容量（トークン）オーバーでエラーになります。古い記憶を捨てる処理を追加します

import asyncio
import random
import traceback  # エラーの詳細を表示するために追加
from config.settings import settings
# 各種モジュールのインポート
from modules.cognition.llm_client import LLMClient
from modules.expression.vtube_studio import VTubeStudioClient
from modules.expression.voicevox import VoicevoxClient
from modules.perception.youtube import YouTubeCommentFetcher

# キャラクター設定
SYSTEM_PROMPT = """
あなたは「AITuber」のアイです。
元気で明るい、少しおっちょこちょいな性格です。
リスナーのコメントに対して、短くテンポよく返事をしてください。
"""

async def main():
    print("🚀 AITuberシステムを起動します...")
    print("✨ 'Ctrl + C' を押すまで、永遠に動き続けます！")

    # 1. 各モジュールの初期化
    brain = LLMClient(system_prompt=SYSTEM_PROMPT)
    voice = VoicevoxClient()
    body = VTubeStudioClient()
    youtube = YouTubeCommentFetcher()

    # 2. VTube Studioに接続（失敗してもリトライし続ける）
    while True:
        try:
            if await body.connect():
                print("✅ VTube Studio接続成功！")
                break
            else:
                print("❌ VTube Studioが見つかりません。5秒後に再試行します...")
                await asyncio.sleep(5)
        except Exception as e:
            print(f"⚠️ VTS接続エラー: {e}")
            await asyncio.sleep(5)

    # 会話履歴
    history = []
    print(f"✅ 準備完了！YouTube配信（ID: {settings.YOUTUBE_VIDEO_ID}）のコメントを監視中...")

    # --- 無限ループ開始 ---
    while True:
        try:
            # --- 1. YouTubeコメントの取得 ---
            comments = youtube.fetch_comments()

            # コメントが来ていない場合は休憩して次へ
            if not comments:
                await asyncio.sleep(5)  # 5秒待機（負荷軽減のため重要！）[1]
                continue

            # 最新のコメントを取得
            last_comment = comments[-1]
            user_name = last_comment["user"]
            user_text = last_comment["text"]

            print(f"\n💬 {user_name}: {user_text}")

            # "終了" コマンドでシステムを安全に停止
            if user_text == "終了":
                print("システムを終了します。")
                break

            # --- 2. 思考 (Brain) ---
            print("🤖 (思考中...)")
            prompt_text = f"リスナーの「{user_name}」さんが「{user_text}」と言っています。返事をしてあげて。"
            
            # AI応答生成（エラーが起きても止まらないようにガード）
            try:
                response_text = await brain.generate_response(prompt_text, history)
            except Exception as e:
                print(f"❌ AI生成エラー: {e}")
                response_text = "ごめんね、ちょっと頭が回らなかったみたい！もう一回言ってくれる？"

            print(f"アイ: {response_text}")

            # 履歴更新
            history.append({"role": "user", "content": f"{user_name}: {user_text}"})
            history.append({"role": "assistant", "content": response_text})
            
            # 【重要】記憶の整理：履歴が20個を超えたら古いものを忘れる[4]
            if len(history) > 20:
                history = history[-10:] # 最新10個だけ残す

            # --- 3. 表現 (Voice & Body) ---
            
            # 口パクのタスク
            async def lip_sync_simulation():
                while True:
                    await body.set_parameter("MouthOpen", random.uniform(0.0, 1.0))
                    await asyncio.sleep(0.1)
            
            # 音声再生と口パクを開始
            lip_task = asyncio.create_task(lip_sync_simulation())
            
            # 声を再生
            try:
                await asyncio.to_thread(voice.speak, response_text)
            except Exception as e:
                print(f"❌ 音声再生エラー: {e}")
            
            # 喋り終わったら口パク停止
            lip_task.cancel()
            await body.set_parameter("MouthOpen", 0.0)

        except KeyboardInterrupt:
            # Ctrl+C が押されたらループを抜ける
            print("\n🛑 強制終了します")
            break
        except Exception as e:
            # 予期せぬエラーが起きても、ログを出してループを継続（これが重要！）
            print(f"⚠️ 予期せぬエラーが発生しましたが、復旧します: {e}")
            traceback.print_exc() # エラーの詳しい場所を表示
            await asyncio.sleep(3) # エラー連打を防ぐため少し休む

    # 終了処理
    await body.close()

if __name__ == "__main__":
    asyncio.run(main())

ログを拾ってコメントを返すプログラムだけど
ターミナルでプログラムを一周実行するたびに終了してしまう。

ちゃんと繰り返してほしい

import asyncio
import random
import traceback # エラーの詳細を表示するために追加
from config.settings import settings

各種モジュールのインポート

from modules.cognition.llm_client import LLMClient
from modules.expression.vtube_studio import VTubeStudioClient
from modules.expression.voicevox import VoicevoxClient
from modules.perception.youtube import YouTubeCommentFetcher

キャラクター設定

SYSTEM_PROMPT = “””
あなたは「AITuber」のアイです。
元気で明るい、少しおっちょこちょいな性格です。
リスナーのコメントに対して、短くテンポよく返事をしてください。
“””

async def main():
print(“🚀 AITuberシステムを起動します…”)
print(“✨ ‘Ctrl + C’ を押すまで、永遠に動き続けます！”)

# 1. 各モジュールの初期化
brain = LLMClient(system_prompt=SYSTEM_PROMPT)
voice = VoicevoxClient()
body = VTubeStudioClient()
youtube = YouTubeCommentFetcher()

# 2. VTube Studioに接続（失敗してもリトライし続ける）
while True:
    try:
        if await body.connect():
            print("✅ VTube Studio接続成功！")
            break
        else:
            print("❌ VTube Studioが見つかりません。5秒後に再試行します...")
            await asyncio.sleep(5)
    except Exception as e:
        print(f"⚠️ VTS接続エラー: {e}")
        await asyncio.sleep(5)

# 会話履歴
history = []
print(f"✅ 準備完了！YouTube配信（ID: {settings.YOUTUBE_VIDEO_ID}）のコメントを監視中...")

# --- 無限ループ開始 ---
while True:
    try:
        # --- 1. YouTubeコメントの取得 ---
        comments = youtube.fetch_comments()

        # コメントが来ていない場合は休憩して次へ
        if not comments:
            await asyncio.sleep(5)  # 5秒待機（負荷軽減のため重要！）[1]
            continue

        # 最新のコメントを取得
        last_comment = comments[-1]
        user_name = last_comment["user"]
        user_text = last_comment["text"]

        print(f"\n💬 {user_name}: {user_text}")

        # "終了" コマンドでシステムを安全に停止
        if user_text == "終了":
            print("システムを終了します。")
            break

        # --- 2. 思考 (Brain) ---
        print("🤖 (思考中...)")
        prompt_text = f"リスナーの「{user_name}」さんが「{user_text}」と言っています。返事をしてあげて。"

        # AI応答生成（エラーが起きても止まらないようにガード）
        try:
            response_text = await brain.generate_response(prompt_text, history)
        except Exception as e:
            print(f"❌ AI生成エラー: {e}")
            response_text = "ごめんね、ちょっと頭が回らなかったみたい！もう一回言ってくれる？"

        print(f"アイ: {response_text}")

        # 履歴更新
        history.append({"role": "user", "content": f"{user_name}: {user_text}"})
        history.append({"role": "assistant", "content": response_text})

        # 【重要】記憶の整理：履歴が20個を超えたら古いものを忘れる[4]
        if len(history) > 20:
            history = history[-10:] # 最新10個だけ残す

        # --- 3. 表現 (Voice & Body) ---

        # 口パクのタスク
        async def lip_sync_simulation():
            while True:
                await body.set_parameter("MouthOpen", random.uniform(0.0, 1.0))
                await asyncio.sleep(0.1)

        # 音声再生と口パクを開始
        lip_task = asyncio.create_task(lip_sync_simulation())

        # 声を再生
        try:
            await asyncio.to_thread(voice.speak, response_text)
        except Exception as e:
            print(f"❌ 音声再生エラー: {e}")

        # 喋り終わったら口パク停止
        lip_task.cancel()
        await body.set_parameter("MouthOpen", 0.0)

    except KeyboardInterrupt:
        # Ctrl+C が押されたらループを抜ける
        print("\n🛑 強制終了します")
        break
    except Exception as e:
        # 予期せぬエラーが起きても、ログを出してループを継続（これが重要！）
        print(f"⚠️ 予期せぬエラーが発生しましたが、復旧します: {e}")
        traceback.print_exc() # エラーの詳しい場所を表示
        await asyncio.sleep(3) # エラー連打を防ぐため少し休む

   # 終了処理
    await body.close()

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import random
import traceback
import uuid
import multiprocessing as mp
import signal
import sys

from config.settings import settings

from modules.cognition.llm_client import LLMClient
from modules.expression.vtube_studio import VTubeStudioClient
from modules.expression.voicevox import VoicevoxClient
from modules.perception.youtube import YouTubeCommentFetcher


SYSTEM_PROMPT = """
あなたは「AITuber」のアイです。
元気で明るい、少しおっちょこちょいな性格です。
リスナーのコメントに対して、短くテンポよく返事をしてください。
"""

MAX_LIP_SECONDS = 12


def drain_queue(q: mp.Queue, max_items: int = 50):
    """
    キューに溜まっている古い音声を捨てる（最新優先）
    ※ mp.Queue の empty/qsize はWindowsで信用できないので get_nowait で抜く
    """
    for _ in range(max_items):
        try:
            q.get_nowait()
        except Exception:
            break


def voice_worker(req_q: mp.Queue):
    voice = VoicevoxClient()
    while True:
        item = req_q.get()
        if item is None:
            break

        _req_id, text = item
        try:
            voice.speak(text)
        except KeyboardInterrupt:
            # Ctrl+C が worker に飛んでも main で止めたいので、ここでは無視して継続
            continue
        except BaseException:
            # worker側が落ちても main は動かし続ける
            traceback.print_exc()


def restart_voice_worker(old_proc: mp.Process, req_q: mp.Queue) -> mp.Process:
    try:
        if old_proc is not None and old_proc.is_alive():
            old_proc.terminate()
            old_proc.join(timeout=2)
    except Exception:
        pass

    proc = mp.Process(target=voice_worker, args=(req_q,), daemon=True)
    proc.start()
    return proc


async def wait_or_stop(seconds: float, stop_event: asyncio.Event):
    try:
        await asyncio.wait_for(stop_event.wait(), timeout=seconds)
    except asyncio.TimeoutError:
        return


async def lip_sync_for(body, seconds: float, stop_event: asyncio.Event):
    end = asyncio.get_running_loop().time() + seconds
    try:
        while not stop_event.is_set() and asyncio.get_running_loop().time() < end:
            await body.set_parameter("MouthOpen", random.uniform(0.0, 1.0))
            await wait_or_stop(0.1, stop_event)
    finally:
        try:
            await body.set_parameter("MouthOpen", 0.0)
        except Exception:
            pass


async def connect_vts_forever(body, stop_event: asyncio.Event):
    while not stop_event.is_set():
        try:
            if await body.connect():
                print("✅ VTube Studio接続成功！")
                return True
            print("❌ VTube Studioが見つかりません。5秒後に再試行します...")
            await wait_or_stop(5, stop_event)
        except Exception as e:
            print(f"⚠️ VTS接続エラー: {e}")
            await wait_or_stop(5, stop_event)
    return False


async def stop_listener(stop_event: asyncio.Event):
    """
    Windows/multiprocessing環境で Ctrl+C が不安定なので、
    「q + Enter」で確実に止める。
    """
    print("🛑 停止したいときは 'q' を入力して Enter（Ctrl+Cは環境により不安定）")
    while not stop_event.is_set():
        try:
            line = await asyncio.to_thread(sys.stdin.readline)
        except Exception:
            await asyncio.sleep(0.5)
            continue

        if not line:
            continue
        if line.strip().lower() in ("q", "quit", "exit"):
            stop_event.set()
            return


async def main():
    print("🚀 AITuberシステムを起動します...")
    print("✨ 'Ctrl + C' を押すまで、永遠に動き続けます！")

    stop_event = asyncio.Event()
    loop = asyncio.get_running_loop()

    # 可能ならSIGINTも stop_event にする（Windowsでは効かない場合あり）
    try:
        loop.add_signal_handler(signal.SIGINT, stop_event.set)
    except NotImplementedError:
        pass

    # 停止入力リスナー（確実に止める保険）
    asyncio.create_task(stop_listener(stop_event))

    brain = LLMClient(system_prompt=SYSTEM_PROMPT)
    body = VTubeStudioClient()
    youtube = YouTubeCommentFetcher()

    req_q: mp.Queue = mp.Queue()
    vp = restart_voice_worker(None, req_q)

    history = []

    try:
        ok = await connect_vts_forever(body, stop_event)
        if not ok:
            return

        print(f"✅ 準備完了！YouTube配信（ID: {settings.YOUTUBE_VIDEO_ID}）のコメントを監視中...")

        last_seen_key = None
        last_alive = asyncio.get_running_loop().time()

        while not stop_event.is_set():
            try:
                comments = youtube.fetch_comments()

                if not comments:
                    now = asyncio.get_running_loop().time()
                    if now - last_alive > 15:
                        print("…待機中（コメントなし）")
                        last_alive = now
                    await wait_or_stop(5, stop_event)
                    continue

                last_comment = comments[-1]
                user_name = last_comment.get("user", "unknown")
                user_text = last_comment.get("text", "")

                comment_id = last_comment.get("id")
                key = comment_id if comment_id is not None else (user_name, user_text)

                if key == last_seen_key:
                    await wait_or_stop(1, stop_event)
                    continue
                last_seen_key = key

                print(f"\n💬 {user_name}: {user_text}")

                if user_text.strip() == "終了":
                    print("システムを終了します。")
                    stop_event.set()
                    break

                print("🤖 (思考中...)")
                prompt_text = f"リスナーの「{user_name}」さんが「{user_text}」と言っています。返事をしてあげて。"

                try:
                    response_text = await brain.generate_response(prompt_text, history)
                except Exception as e:
                    print(f"❌ AI生成エラー: {e}")
                    response_text = "ごめんね、ちょっと頭が回らなかったみたい！もう一回言ってくれる？"

                if stop_event.is_set():
                    break

                print(f"アイ: {response_text}")

                history.append({"role": "user", "content": f"{user_name}: {user_text}"})
                history.append({"role": "assistant", "content": response_text})
                if len(history) > 20:
                    history = history[-10:]

                if not vp.is_alive():
                    print("⚠️ 音声ワーカーが停止していました。再起動します。")
                    vp = restart_voice_worker(vp, req_q)

                # ★古い音声を捨てて、最新だけ喋らせる（テキストと音声のズレ防止）
                drain_queue(req_q)
                req_q.put((str(uuid.uuid4()), response_text))

                await lip_sync_for(body, MAX_LIP_SECONDS, stop_event)

                print("✅ ループ継続：次のコメント取得へ")

            except KeyboardInterrupt:
                stop_event.set()
                break
            except Exception as e:
                print(f"⚠️ ループ内エラー（継続します）: {e}")
                traceback.print_exc()
                await wait_or_stop(3, stop_event)

    finally:
        try:
            await body.close()
        except Exception:
            pass

        try:
            req_q.put(None)
        except Exception:
            pass

        try:
            if vp is not None and vp.is_alive():
                vp.terminate()
                vp.join(timeout=2)
        except Exception:
            pass

        print("👋 終了しました")


if __name__ == "__main__":
    mp.freeze_support()
    asyncio.run(main())