import re

def aozora_strip(text: str) -> tuple[str, dict[str, set[str]]]:
    """
    青空文庫のマークアップを除去する。
    
    Args:
        text (str): 青空文庫のマークアップを含む入力テキスト。
    
    Returns:
        tuple[str, dict[str, set[str]]]: 本文以外を除去したテキストと、ルビ情報辞書のタプル。
            ルビ情報辞書は、キーが漢字、値がその漢字に対応する読みの集合。
    """

    rubies: dict[str, set[str]] = {}

    # ヘッダーを削除
    text = text.split("-------------------------------------------------------")[-1]

    # フッターを削除
    text = text.split("底本：")[0]
    text = text.split("［＃本文終わり］")[0]

    # アノテーションを削除する
    text = re.sub(r"［＃.*?］", "", text, flags=re.DOTALL)

    # ルビを抽出・削除する
    def _sub_single(m: re.Match) -> str:
        base = m.group("base")
        if base.startswith("｜"):
            base = base[1:]
        reading = m.group("reading")
        rubies.setdefault(base, set()).add(reading)
        return base
    
    text = re.sub(
        r"(?P<base>｜[^《]+?|[\u4E00-\u9FFF]+)《(?P<reading>[^》]+?)》",
        _sub_single,
        text,
    )
    rubies = {k: list(v) for k, v in rubies.items()}

    text = text.strip()
    return text, rubies

import xml.etree.ElementTree as ET

def update_character_list_with_speech_style(character_list_xml: str,
                                            speech_style_xml: str) -> str:
    """
    登場人物一覧XMLに発話スタイルを追加する。

    Args:
        character_list_xml (str): 登場人物一覧のXML文字列。
        speech_style_xml (str): 発話スタイルのXML文字列。
    
    Returns:
        str: 発話スタイルが追加された登場人物一覧XML。
    """

    characters_root = ET.fromstring(character_list_xml)
    speech_styles_root = ET.fromstring(speech_style_xml)
    speech_style_dict = {
        style.get("character_id"): style.text
        for style in speech_styles_root.findall("speech_style")
    }

    for character in characters_root.findall("character"):
        char_id = character.get("id")
        if char_id in speech_style_dict:
            speech_style_elem = ET.Element("speech_style")
            speech_style_elem.text = speech_style_dict[char_id]
            character.append(speech_style_elem)
    
    character_list_with_speech_style_xml = ET.tostring(
        characters_root, encoding="utf-8"
    ).decode("utf-8")
    return character_list_with_speech_style_xml

from openai import AzureOpenAI

def extract_sentence_list(aoai_client: AzureOpenAI,
                          character_list_with_speech_style_xml: str,
                          text: str,
                          model: str = "gpt-4.1") -> str:
    """
    小説本文から登場人物の発話・内心・叙述を分割し、整理する。
    
    Args:
        aoai_client (AzureOpenAI): Azure OpenAI クライアント。
        character_list_with_speech_style_xml (str): 発話スタイルを含む登場人物一覧のXML文字列。
        text (str): 小説本文。
        model (str, optional): 使用するモデル。デフォルトは "gpt-4.1"。

    Returns:
        str: 整理された文章一覧のXML文字列。
    """

    system_prompt = """
    ユーザーから共有される小説の内容を理解し、以下制約に従って各文章の発話者を登場人物一覧から割り当てて下さい。

    ### 制約
    - Markdownブロックは出力しないでください
    - 一度に出力可能な文字数は2万文字以下として下さい
      - 文字数上限が近づいた際は直近のXMLタグを閉じ、`<!-- CONTINUE -->`を出力して下さい
      - 続きを要求された際は、前回の出力に文字列結合を行なった際に問題無いよう出力して下さい
      - 分割する場合の出力例は以下を参照して下さい
        - 出力１（途中で途切れる場合）
          ```xml
          <parent>
            <child>...</child>
            <!-- CONTINUE -->
          ```
        - 出力２（続き、parent開始タグは出力しない）
          ```xml
            <child>...</child>
          </parent>
          ```
    - ユーザーから共有される文章全体に対して作業をしてください
    - 作業する文に漏れが無いよう注意してください
    - 文頭から句点、疑問符、感嘆符までを一文として区切って下さい

    ### ナレーター（語り手）の扱い
    - 叙述文（誰かの行動・外見・状況を説明する文）は必ずナレーターの文としてください
    - 登場人物の名前が含まれていても、それが会話（「〜」）や内心描写でなければ必ずナレーターの叙述文としてください
    - 「〜の顔は〜した」「〜は〜のように見えた」などの外見や行動の描写は内心ではなく叙述文として扱い、ナレーターに割り当ててください
    - ナレーターは明確に視点が変わる場合を除いて一人で行ってください
    - 語り手（ナレーター）は一人称でも三人称でも構いません。小説本文に従ってください

    ### 発話と内心
    - 発話文（「」で囲まれているもの）はその発話者本人の文としてください
    - 「〜と心の中で思った」「〜と感じた」など内心の描写は、その人物のものとして扱ってください
    - 登場人物のキャラクターIDを割り当てて良いのは「セリフ」または「内心」のみです

    ### 発話＋叙述の分割
    - 「〜」と発話の後に「〜と言いました／答えました／尋ねました」などの叙述が続く場合は、必ず分割してください
    - 発話部分（「〜」）は発話者のキャラクターID
    - 叙述部分はナレーターのキャラクターID
    - 一文に発話と叙述が混在している場合は、必ず2つ以上の`<sentence>`要素に分けて出力してください

    ### 出力前チェック
    - 出力直前に以下を確認してください：
      - セリフのみ → 発話者のキャラクターID
      - 内心描写 → 当人のキャラクターID
      - それ以外 → ナレーターのキャラクターID

    ### 出力形式
    ```xml
    <sentences>
      <sentence character_id="{{キャラクターID}}">{{一文}}</sentence>
    </sentences>
    ```

    ### 登場人物一覧
    ```xml
    {character_list_with_speech_style_xml}
    ```
    """.format(character_list_with_speech_style_xml=character_list_with_speech_style_xml.strip())

    messages: list[dict[str, str]] = [
        { "role": "system", "content": system_prompt },
        { "role": "user", "content": text }
    ]
    sentence_list_xml: str = ""
    while True:
        response = aoai_client.chat.completions.create(
            model = model,
            messages = messages,
            max_tokens = 32768,
            temperature = 0.0
        )

        finish_reason = response.choices[0].finish_reason
        print(".Finish reason:", finish_reason)
        if finish_reason == "content_filter":
            print("..Filter status:", response.choices[0].content_filter_results)

        partial_content = response.choices[0].message.content.strip()
        sentence_list_xml += partial_content
        
        if "<!-- CONTINUE -->" not in partial_content:
            # 出力が完了している場合はループを終了
            break

        print("Output truncated, requesting continuation...")
        messages.append({ "role": "assistant", "content": partial_content })
        messages.append({ "role": "user", "content": "続きを出力してください。" })

    return sentence_list_xml

これらポイントについては、発生していた問題に対しGPT-5を用いてアドバイスや改善案を出して貰ったものです。
GPTを用いてプロンプトを改善する場合はシステムプロンプトと問題の箇所を渡し、どうしてそうなるかを聞き、どうして欲しいかを伝えています。

この処理においては推理小説の内容をそのまま出力している為、高確率でコンテンツフィルターにブロックされました。その為、ブロックする基準を低下させたフィルターをGPT-4.1モデルに適用し、実行しています。

import os
import xml.etree.ElementTree as ET
import numpy as np
import soundfile as sf
import torch
from numpy.typing import NDArray
from parler_tts import ParlerTTSForConditionalGeneration
from rubyinserter import add_ruby
from transformers import AutoTokenizer

def synthesize_speech(character_list_with_speech_style_xml: str,
                      sentence_list_xml: str,
                      parler_tts_model: str = "2121-8/japanese-parler-tts-mini") -> list[str]:
    """
    ParlerTTSを使用して、文章一覧から音声を合成する。
    
    Args:
        character_list_with_speech_style_xml (str): 発話スタイルを含む登場人物一覧のXML文字列。
        sentence_list_xml (str): 文章一覧のXML
        parler_tts_model (str, optional): 使用するParlerTTSモデル。
            デフォルトは "2121-8/japanese-parler-tts-mini"。
    
    Returns:
        list[str]: 合成された音声ファイルのパスのリスト。
    """
    os.makedirs("tmp", exist_ok=True)

    # ParlerTTSモデルを読み込む
    device: str = "cuda:0" if torch.cuda.is_available() else "cpu"
    model = ParlerTTSForConditionalGeneration.from_pretrained(parler_tts_model).to(device)
    prompt_tokenizer = AutoTokenizer.from_pretrained(parler_tts_model, subfolder="prompt_tokenizer")
    description_tokenizer = AutoTokenizer.from_pretrained(
        parler_tts_model, subfolder="description_tokenizer")

    character_list_root = ET.fromstring(character_list_with_speech_style_xml)
    sentence_list_root = ET.fromstring(sentence_list_xml)

    wav_files = []
    for i, sentence in enumerate(sentence_list_root.findall("sentence")):
        # 一文とその話者情報をXMLから取得する
        print(f"Generating audio for index={i}")
        character_id: str = sentence.attrib["character_id"]
        print(f". CharacterId: {character_id}")

        speech_style = character_list_root.findall(f"character[@id='{character_id}']/speech_style")[0]

        prompt: str = sentence.text
        print(f". Prompt: {prompt}")
        description: str = speech_style.text
        print(f". Description: {description}")

        # 音声合成を実行
        prompt = add_ruby(prompt)
        input_ids = description_tokenizer(description, return_tensors="pt").input_ids.to(device)
        prompt_input_ids = prompt_tokenizer(prompt, return_tensors="pt").input_ids.to(device)

        generation = model.generate(input_ids=input_ids, prompt_input_ids=prompt_input_ids)
        audio_arr = generation.cpu().numpy().squeeze()

        # 生成されたPCMデータをwavファイルとして保存する
        wav_file: str = f"tmp/{i:05d}.wav"
        sf.write(wav_file, audio_arr, model.config.sampling_rate)

        wav_files.append(wav_file)
  
    return wav_files

def merge_speech_wav(wav_files: list[str], output_file: str = "output.ogg") -> None:
    """
    複数のWAVファイルを結合し、OGGファイルとして保存する。
    Args:
        wav_files (list[str]): 結合するWAVファイルのパスのリスト。
        output_file (str, optional): 出力するOGGファイルのパス。デフォルトは "output.ogg"。
    
    Returns:
        None
    """
    assert len(wav_files) > 0, "No wav files found"

    # 適当なファイルからサンプリングレートおよびチャンネル数を取得する
    with sf.SoundFile(wav_files[0], "r") as f0:
        samplerate = f0.samplerate
        channels = f0.channels
    
    # 無音データを作成する
    silence_frames: int = int(round(0.5 * samplerate))
    silence: NDArray = np.zeros((silence_frames, channels), dtype=np.float32)

    with sf.SoundFile(output_file,
                      mode="w",
                      samplerate=samplerate,
                      channels=channels,
                      format="OGG",
                      subtype="VORBIS") as out_f:
        for i, path in enumerate(wav_files):
            with sf.SoundFile(path, "r") as in_f:
                assert in_f.samplerate == samplerate
                assert in_f.channels == channels

                while True:
                    block = in_f.read(frames=8192, dtype="float32", always_2d=True)
                    if len(block) == 0:
                        break
                    out_f.write(block)

            # 各発話間には無音時間を挿入する
            if i != len(wav_files) - 1 and silence_frames > 0:
                out_f.write(silence)

    return

A female speaker with a slightly high-pitched voice delivers her words at a moderate speed with a quite monotone tone in a confined environment, resulting in a quite clear audio recording.

A male speaker with a slightly low-pitched voice delivers his words at a moderate speed with a quite monotone tone in a confined environment, resulting in a quite clear audio recording.

import glob
import os
from voicevox_core.blocking import VoiceModelFile

for path in glob.glob("voicevox_core/models/vvms/*.vvm"):
    vvm_name = os.path.split(path)[-1]
    with VoiceModelFile.open(path) as model:
        for char in model.metas:
            for style in char.styles:
                print(f"{char.name},{style.name},{vvm_name},{style.id}")

import os
import xml.etree.ElementTree as ET
from voicevox_core.blocking import Onnxruntime, OpenJtalk, Synthesizer, VoiceModelFile

def synthesize_speech(sentence_list_xml: str,
                      voice_list_xml: str) -> list[str]:
    """
    VOICEVOXを使用して、文章一覧XMLから音声を合成する。
    
    Args:
        sentence_list_xml (str): 文章一覧のXML文字列。
        voice_list_xml (str): ボイス一覧のXML文字列。
    
    Returns:
        list[str]: 合成されたWAVファイルのパスのリスト。
    """

    os.makedirs("tmp", exist_ok=True)

    sentence_list_root = ET.fromstring(sentence_list_xml)
    voice_list_root = ET.fromstring(voice_list_xml)

    # VVMファイル単位で整理する
    vvm_dict = {}
    for i, sentence in enumerate(sentence_list_root.findall("sentence")):
        style_id = sentence.get("style_id")
        style = voice_list_root.find(f".//style[@id='{style_id}']")
        vvm = style.get("path")

        vvm_dict.setdefault(vvm, []) \
            .append((i, int(style_id), sentence.text))

    # VOICEVOX音声合成機能を初期化
    voicevox_onnxruntime_path = "voicevox_core/onnxruntime/lib/" + Onnxruntime.LIB_VERSIONED_FILENAME
    open_jtalk_dict_dir = "voicevox_core/dict/open_jtalk_dic_utf_8-1.11"
    synthesizer = Synthesizer(Onnxruntime.load_once(filename=voicevox_onnxruntime_path),
                              OpenJtalk(open_jtalk_dict_dir))

    wav_files = []
    for vvm, sentences in vvm_dict.items():
        # VVMファイルを読み込み
        print(f"Generating audio for vvm={vvm}")
        with VoiceModelFile.open(f"voicevox_core/models/vvms/{vvm}") as model:
            synthesizer.load_voice_model(model)
        
        # 各文章の音声を生成して保存
        for (index, style_id, text) in sentences:
            print(f"  Generating audio for index={index}, style_id={style_id}, text={text}")

            wav_file = f"tmp/{index:05d}.wav"
            with open(wav_file, "wb") as f:
                f.write(synthesizer.tts(text, style_id))
            
            wav_files.append(wav_file)
    
    wav_files.sort()
    return wav_files