temperature が効いているかを測るより渡した値を記録する方が先です

# audit_static.py — 非推奨キーの静的検出
import ast, pathlib, sys
 
DEPRECATED = {"temperature", "top_p", "top_k"}
 
class Finder(ast.NodeVisitor):
    def __init__(self, path):
        self.path, self.hits = path, []
 
    def _hit(self, node, how, key):
        self.hits.append((self.path, node.lineno, how, key))
 
    def visit_Call(self, node):          # f(temperature=...)
        for kw in node.keywords:
            if kw.arg in DEPRECATED:
                self._hit(node, "keyword-arg", kw.arg)
        self.generic_visit(node)
 
    def visit_Dict(self, node):          # {"temperature": ...}
        for k in node.keys:
            if isinstance(k, ast.Constant) and k.value in DEPRECATED:
                self._hit(node, "dict-literal", k.value)
        self.generic_visit(node)
 
    def visit_Subscript(self, node):     # cfg["temperature"] = ...
        s = node.slice
        if isinstance(s, ast.Constant) and s.value in DEPRECATED:
            self._hit(node, "subscript-assign", s.value)
        self.generic_visit(node)
 
hits = []
for p in sorted(pathlib.Path(sys.argv[1]).rglob("*.py")):
    f = Finder(str(p))
    f.visit(ast.parse(p.read_text(encoding="utf-8")))
    hits += f.hits
 
for h in hits:
    print(f"{h[0]}:{h[1]}  {h[2]:<16} {h[3]}")
print(f"--- AST 検出: {len(hits)} 件 / ファイル {len({h[0] for h in hits})} 本")

# recorder.py（第1版）
import functools, inspect, json, os, time
 
DEPRECATED = ("temperature", "top_p", "top_k")
LEDGER = os.environ.get("GENAI_CONFIG_LEDGER", "config_ledger.jsonl")
 
def _as_dict(config):
    if config is None:
        return {}
    if isinstance(config, dict):
        return dict(config)
    if hasattr(config, "to_dict"):
        return config.to_dict()
    return {k: v for k, v in vars(config).items() if not k.startswith("_")}
 
def record_configs(models):
    original = models.generate_content
 
    @functools.wraps(original)
    def wrapped(*args, **kwargs):
        cfg = _as_dict(kwargs.get("config"))
        entry = {
            "ts": time.strftime("%Y-%m-%dT%H:%M:%S"),
            "model": kwargs.get("model"),
            "origin": f"{inspect.stack()[1].filename}:{inspect.stack()[1].lineno}",
            "deprecated": [k for k in DEPRECATED if k in cfg],
        }
        with open(LEDGER, "a", encoding="utf-8") as f:
            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
        return original(*args, **kwargs)
 
    models.generate_content = wrapped
    return models

# tracked.py
import inspect, os
 
_SKIP = {os.path.abspath(__file__)}
 
def register_factory(path: str) -> None:
    """設定を組み立てる共通ヘルパを、原点探索の対象から外す。"""
    _SKIP.add(os.path.abspath(path))
 
class TrackedConfig(dict):
    __slots__ = ("origin", "chain")
 
    def __init__(self, mapping=None, /, **kw):
        super().__init__(mapping or {}, **kw)
        self.chain = _origin_chain(depth=2)
        self.origin = self.chain[0] if self.chain else "unknown"
 
    def plain(self) -> dict:
        """送信直前に、素の dict へ戻す。"""
        return dict(self)
 
def _origin_chain(depth: int = 2):
    out = []
    for fr in inspect.stack()[1:]:
        if os.path.abspath(fr.filename) in _SKIP:
            continue
        out.append(f"{os.path.relpath(fr.filename)}:{fr.lineno}")
        if len(out) >= depth:
            break
    return out

# app/common/config.py
import json, os
from tracked import TrackedConfig, register_factory
 
BASE = {"max_output_tokens": 1024}
 
def load_profile(name: str) -> dict:
    path = os.path.join(os.path.dirname(__file__), "profiles", f"{name}.json")
    with open(path, encoding="utf-8") as f:
        return TrackedConfig(json.load(f))
 
def merged(profile_name: str, **override) -> dict:
    return TrackedConfig({**BASE, **load_profile(profile_name), **override})
 
register_factory(__file__)   # このファイルを原点にしない

# ci_gate.py
import json, sys, collections
 
rows = [json.loads(l) for l in open(sys.argv[1], encoding="utf-8")]
untracked = [r for r in rows if r["origin"] == "untracked"]
by_origin = collections.Counter(r["origin"] for r in rows if r["deprecated"])
 
print(f"記録された呼び出し: {len(rows)} 件 / 追跡できなかった呼び出し: {len(untracked)} 件")
for origin, n in sorted(by_origin.items()):
    keys = sorted({k for r in rows if r["origin"] == origin for k in r["deprecated"]})
    print(f"  {origin:<30} {n:>3} 回  {', '.join(keys)}")
 
if untracked:
    print("❌ TrackedConfig を経由していない呼び出しがあります（棚卸しが不完全です）")
    sys.exit(1)
if by_origin:
    print(f"❌ 非推奨キーを渡している箇所が {len(by_origin)} 件残っています")
    sys.exit(1)
print("✅ 非推奨キーの送出はありません")

client.models.generate_content(
    model="gemini-3.7-flash", contents="ping", config={"temperature": 0.7}
)