def create_structured_prompt(task: str, schema: dict) -> str:
    """構造化出力を促すプロンプトを生成"""
    schema_str = json.dumps(schema, ensure_ascii=False, indent=2)
    return f"""
以下のタスクを実行し、必ず下記のJSONスキーマに従って出力してください。
 
タスク: {task}
 
出力スキーマ:
```json
{schema_str}

from antigravity import Agent  # 仮のAntigravity SDK
 
async def get_validated_output(
    agent: Agent,
    task: str,
    schema: dict,
    max_retries: int = 3
) -> Optional[dict]:
    """
    バリデーションが通るまで自動リトライする
    """
    for attempt in range(max_retries):
        prompt = create_structured_prompt(task, schema)
        raw_output = await agent.run(prompt)
 
        # パース試行
        parsed = parse_agent_output(raw_output)
        if parsed is None:
            if attempt < max_retries - 1:
                # リトライ用プロンプトで修正を依頼
                task = f"""
前回の出力がJSONとして正しくパースできませんでした。
前回の出力: {raw_output[:500]}
 
修正してください: {task}
"""
                continue
            return None
 
        # スキーマ検証
        is_valid, errors = validate_output(parsed, schema)
        if is_valid:
            return parsed
 
        if attempt < max_retries - 1:
            # エラーを伝えて修正を依頼
            error_list = "\n".join(f"- {e}" for e in errors)
            task = f"""
前回の出力に以下の問題がありました:
{error_list}
 
修正してください: {task}
"""
        else:
            print(f"バリデーション失敗 (最終試行): {errors}")
            return None
 
    return None

QUALITY_CHECK_PROMPT = """
以下のエージェント出力を品質評価してください。
 
タスク: {task}
出力: {output}
 
以下の基準で評価し、JSONで返してください:
{{
  "meets_requirements": true/false,
  "quality_score": 0.0〜1.0,
  "issues": ["問題点のリスト"],
  "needs_revision": true/false,
  "revision_guidance": "修正が必要な場合の指示"
}}
 
評価基準:
1. タスクの要件をすべて満たしているか
2. 情報が具体的で実用的か
3. 内容に矛盾や誤りはないか
4. 必要な情報量が含まれているか
"""
 
async def get_quality_checked_output(
    primary_agent: Agent,
    checker_agent: Agent,
    task: str,
    schema: dict,
    min_quality_score: float = 0.7
) -> Optional[dict]:
    """セルフチェック付きの出力生成"""
 
    for attempt in range(3):
        # プライマリエージェントで出力生成
        output = await get_validated_output(primary_agent, task, schema)
        if output is None:
            continue
 
        # チェッカーエージェントで品質評価
        check_prompt = QUALITY_CHECK_PROMPT.format(
            task=task,
            output=json.dumps(output, ensure_ascii=False)
        )
        check_raw = await checker_agent.run(check_prompt)
        check_result = parse_agent_output(check_raw, {})
 
        if check_result is None:
            # チェック自体が失敗した場合は出力をそのまま使用
            return output
 
        quality_score = check_result.get("quality_score", 0)
        needs_revision = check_result.get("needs_revision", False)
 
        if not needs_revision and quality_score >= min_quality_score:
            return output
 
        if attempt < 2:
            # 修正指示を追加してリトライ
            guidance = check_result.get("revision_guidance", "品質を改善してください")
            issues = check_result.get("issues", [])
            task = f"{task}\n\n改善指示:\n{guidance}\n問題点: {', '.join(issues)}"
        else:
            # 最終試行でも品質不足の場合は低品質フラグを付けて返す
            output["_quality_warning"] = {
                "score": quality_score,
                "issues": check_result.get("issues", [])
            }
            return output
 
    return None

from collections import Counter
from typing import List
 
async def get_consensus_output(
    agent: Agent,
    task: str,
    num_samples: int = 3,
    schema: dict = None
) -> Optional[dict]:
    """
    複数回実行して多数決で最終出力を決定する
    （確率的な揺れを抑制する）
    """
    outputs = []
 
    for _ in range(num_samples):
        output = await get_validated_output(agent, task, schema or {})
        if output:
            outputs.append(output)
 
    if not outputs:
        return None
 
    if len(outputs) == 1:
        return outputs[0]
 
    # 文字列フィールドは最も多く出現した値を採用
    consensus = {}
    all_keys = set().union(*[o.keys() for o in outputs])
 
    for key in all_keys:
        if key.startswith("_"):  # 内部フィールドはスキップ
            continue
 
        values = [str(o.get(key, "")) for o in outputs if key in o]
 
        if not values:
            continue
 
        if isinstance(outputs[0].get(key), (int, float)):
            # 数値は平均値を使用
            numeric_values = [o[key] for o in outputs if key in o and isinstance(o[key], (int, float))]
            consensus[key] = sum(numeric_values) / len(numeric_values)
        elif isinstance(outputs[0].get(key), list):
            # リストは出現頻度の高いアイテムを優先
            all_items = [item for o in outputs for item in o.get(key, [])]
            item_counts = Counter(all_items)
            consensus[key] = [item for item, _ in item_counts.most_common()]
        else:
            # 文字列は最頻値を使用
            consensus[key] = Counter(values).most_common(1)[0][0]
 
    return consensus

import time
from dataclasses import dataclass, field
from collections import defaultdict
 
@dataclass
class ValidationMetrics:
    total_attempts: int = 0
    format_errors: int = 0
    quality_errors: int = 0
    success_count: int = 0
    retry_counts: list = field(default_factory=list)
    error_details: list = field(default_factory=list)
 
    @property
    def success_rate(self) -> float:
        return self.success_count / self.total_attempts if self.total_attempts > 0 else 0
 
    @property
    def avg_retries(self) -> float:
        return sum(self.retry_counts) / len(self.retry_counts) if self.retry_counts else 0
 
    def alert_if_needed(self):
        if self.success_rate < 0.8:
            print(f"⚠️ 出力検証成功率が低下: {self.success_rate:.1%}")
        if self.avg_retries > 1.5:
            print(f"⚠️ 平均リトライ回数が高い: {self.avg_retries:.1f}回")
 
metrics = ValidationMetrics()