qwen3-6-lora/scripts/32_gate2_toolcalls.py

"""Fase 4 -- Puerta 2: validez de tool-calls contra el parser real de vLLM.

Corre LOCALMENTE (no necesita GPU) contra el endpoint HTTP del contenedor de eval propio
(vllm-eval, docker-compose.eval.yml, puerto 8001 por defecto) ya levantado y respondiendo
en /v1/models.

Para cada prompt de data/holdout_prompts.jsonl (~200, generados por
scripts/31_build_holdout_prompts.py, sin overlap con train/eval): envia una sola llamada a
/v1/chat/completions con las tools reales del MCP correspondiente y
tool_choice="auto". El parseo de tool_calls (`--tool-call-parser=qwen3_coder`,
configurado en docker-compose.eval.yml) lo hace vLLM en el servidor -- este script solo
valida la RESPUESTA ya parseada (nunca re-implementa el parser con una regex propia):

  - Si el modelo decide llamar una tool: valida que el nombre exista en el schema del MCP,
    que los argumentos parseen como JSON valido, que las propiedades "required" del
    schema esten presentes, y que NINGUNA clave de argumento este ausente de
    `parameters.properties` del schema.
  - Si el modelo NO llama ninguna tool: se cuenta aparte (no es un error per se, algunos
    prompts pueden resolverse sin tool-call, pero se reporta la tasa).

Reporta: % de prompts con tool_call sintacticamente valido (parseado sin excepcion por
vLLM, arguments=JSON valido, nombre, campos requeridos y claves de argumento correctos)
por MCP y global.

FASE 6 -- la puerta premiaba la invencion de parametros
-------------------------------------------------------
Hasta la Fase 5 `validate_tool_call` solo chequeaba los `required` del schema: un argumento
INVENTADO que el schema no declara (`scale`, `filePath` en `export_shape`) **pasaba la
puerta**. Es decir, la puerta 2 premiaba activamente el comportamiento que la Fase 6 quiere
eliminar. Ahora toda clave ausente de `parameters.properties` es un fallo, contabilizado en
su propia categoria `unknown_argument` -- separada de `missing_required`, porque son errores
distintos y queremos poder medir la invencion por si sola.

El formato del JSON de resultados se mantiene compatible con los `gate2_results*.json` de las
Fases 4-5: las claves viejas siguen ahi con el mismo significado, las nuevas son aditivas.
"""
import argparse
import json
import os
import sys
import time
from collections import defaultdict
from pathlib import Path

import requests

REPO_ROOT = Path(__file__).resolve().parent.parent
HOLDOUT_PATH = REPO_ROOT / "data" / "holdout_prompts.jsonl"
RESULTS_PATH = REPO_ROOT / "data" / os.environ.get("GATE2_RESULTS_FILENAME", "gate2_results.json")
BASE_URL = os.environ.get("VLLM_EVAL_URL", "http://localhost:8001")
MODEL_NAME = os.environ.get("VLLM_EVAL_MODEL", "qwen3.6-35b-a3b-mcp-bf16")
# 1024 dejaba cortar la respuesta a mitad de razonamiento en modelos con
# --reasoning-parser activo antes de emitir el tool_call -- ver hallazgo de
# Fase 5 (misma causa que el fix de gate3, max_tokens 512->2048).
GATE2_MAX_TOKENS = int(os.environ.get("GATE2_MAX_TOKENS", "2048"))


def load_holdout():
    examples = []
    with open(HOLDOUT_PATH, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if line:
                examples.append(json.loads(line))
    return examples


def tool_by_name(tools, name):
    for tool in tools:
        if tool.get("name") == name or tool.get("function", {}).get("name") == name:
            return tool
    return None


def to_openai_tools(tools):
    openai_tools = []
    for tool in tools:
        if "function" in tool:
            openai_tools.append(tool)
        else:
            openai_tools.append({
                "type": "function",
                "function": {
                    "name": tool["name"],
                    "description": tool.get("description", ""),
                    "parameters": tool.get("inputSchema") or tool.get("parameters") or {"type": "object", "properties": {}},
                },
            })
    return openai_tools


# Categorias de fallo, contabilizadas por separado. `unknown_argument` es la que mide
# invencion de parametros y por eso no se mezcla con `missing_required`.
FAILURE_KINDS = ("invalid_json", "unknown_tool", "missing_required", "unknown_argument")


def validate_tool_call(tool_call, tools):
    """Devuelve (ok, mensaje_de_error, categoria_de_fallo).

    La categoria es None cuando la llamada es valida.
    """
    name = tool_call["function"]["name"]
    raw_args = tool_call["function"]["arguments"]
    try:
        args = json.loads(raw_args)
    except json.JSONDecodeError as e:
        return False, f"arguments no es JSON valido: {e}", "invalid_json"

    tool_def = tool_by_name(tools, name)
    if tool_def is None:
        return False, f"tool_call a nombre inexistente en el schema del MCP: {name}", "unknown_tool"

    schema = tool_def.get("inputSchema") or tool_def.get("parameters") or {}
    required = schema.get("required", [])
    missing = [r for r in required if r not in args]
    if missing:
        return False, f"faltan campos requeridos {missing} en la llamada a {name}", "missing_required"

    # Invencion de parametros: cualquier clave que el schema no declare. Solo se puede
    # juzgar si el schema declara `properties`; si no las declara (schema abierto), no hay
    # con que comparar y no se penaliza.
    properties = schema.get("properties")
    if isinstance(properties, dict) and properties and isinstance(args, dict):
        unknown = sorted(k for k in args if k not in properties)
        if unknown:
            return (
                False,
                f"argumentos inventados {unknown} ausentes de properties del schema de {name}",
                "unknown_argument",
            )

    return True, None, None


def call_vllm(prompt, tools, timeout=240):
    payload = {
        "model": MODEL_NAME,
        "messages": [{"role": "user", "content": prompt}],
        "tools": to_openai_tools(tools),
        "tool_choice": "auto",
        "max_tokens": GATE2_MAX_TOKENS,
        "temperature": 0.0,
    }
    resp = requests.post(f"{BASE_URL}/v1/chat/completions", json=payload, timeout=timeout)
    resp.raise_for_status()
    return resp.json()


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--limit", type=int, default=None)
    args = parser.parse_args()

    examples = load_holdout()
    if args.limit:
        examples = examples[: args.limit]
    print(f"[INFO] {len(examples)} prompts held-out, endpoint={BASE_URL}")

    results = []
    # Las cuatro claves originales se mantienen tal cual para poder comparar contra los
    # gate2_results*.json de las Fases 4-5; las de FAILURE_KINDS son aditivas.
    def new_stats():
        base = {"total": 0, "valid_tool_call": 0, "no_tool_call": 0, "invalid": 0}
        base.update({kind: 0 for kind in FAILURE_KINDS})
        base["request_error"] = 0
        return base

    stats = defaultdict(new_stats)

    t0 = time.time()
    for i, ex in enumerate(examples):
        mcp = ex["mcp"]
        stats[mcp]["total"] += 1
        stats["__global__"]["total"] += 1
        try:
            response = call_vllm(ex["prompt"], ex["tools"])
        except Exception as e:
            results.append({"mcp": mcp, "prompt": ex["prompt"], "error": str(e)})
            stats[mcp]["invalid"] += 1
            stats["__global__"]["invalid"] += 1
            stats[mcp]["request_error"] += 1
            stats["__global__"]["request_error"] += 1
            continue

        message = response["choices"][0]["message"]
        # Se guarda siempre el texto completo (content + reasoning) para poder auditar
        # con criterio humano los casos que fallan o quedan sin tool_call -- antes no se
        # guardaba nada de esto, lo que hacia imposible diagnosticar truncamiento.
        content = message.get("content") or ""
        reasoning = message.get("reasoning") or ""
        tool_calls = message.get("tool_calls") or []
        if not tool_calls:
            stats[mcp]["no_tool_call"] += 1
            stats["__global__"]["no_tool_call"] += 1
            results.append({
                "mcp": mcp,
                "prompt": ex["prompt"],
                "expect": ex.get("expect"),
                "tool_calls": None,
                "valid": None,
                "content": content,
                "reasoning": reasoning,
                "finish_reason": response["choices"][0].get("finish_reason"),
            })
            continue

        all_valid = True
        errors = []
        error_kinds = []
        for tc in tool_calls:
            ok, err, kind = validate_tool_call(tc, ex["tools"])
            if not ok:
                all_valid = False
                errors.append(err)
                if kind not in error_kinds:
                    error_kinds.append(kind)

        if all_valid:
            stats[mcp]["valid_tool_call"] += 1
            stats["__global__"]["valid_tool_call"] += 1
        else:
            stats[mcp]["invalid"] += 1
            stats["__global__"]["invalid"] += 1
            # Un prompt puede acumular mas de una categoria si emitio varias tool_calls;
            # se cuenta una vez por categoria distinta, nunca dos veces la misma.
            for kind in error_kinds:
                stats[mcp][kind] += 1
                stats["__global__"][kind] += 1

        results.append({
            "mcp": mcp,
            "prompt": ex["prompt"],
            "expect": ex.get("expect"),
            "tool_calls": [tc["function"]["name"] for tc in tool_calls],
            "valid": all_valid,
            "errors": errors,
            "error_kinds": error_kinds,
            "content": content,
            "reasoning": reasoning,
            "finish_reason": response["choices"][0].get("finish_reason"),
        })

        if (i + 1) % 20 == 0:
            print(f"[INFO] {i + 1}/{len(examples)} prompts procesados")

    dt = time.time() - t0
    print(f"\n=== Puerta 2 -- validez de tool-calls (parser real de vLLM) ===")
    print(f"[INFO] tiempo total: {dt:.1f}s\n")
    for mcp in sorted(stats):
        s = stats[mcp]
        pct_valid = 100 * s["valid_tool_call"] / s["total"] if s["total"] else 0
        print(
            f"  {mcp:20s} total={s['total']:4d} valid={s['valid_tool_call']:4d} "
            f"no_tool_call={s['no_tool_call']:4d} invalid={s['invalid']:4d} "
            f"pct_valid={pct_valid:.1f}%"
        )

    print("\n--- desglose de fallos por categoria ---")
    for mcp in sorted(stats):
        s = stats[mcp]
        detalle = " ".join(f"{kind}={s.get(kind, 0)}" for kind in FAILURE_KINDS)
        print(f"  {mcp:20s} {detalle} request_error={s.get('request_error', 0)}")

    # La invencion de parametros se reporta aparte porque es la metrica que la Fase 6
    # quiere llevar a cero: hasta la Fase 5 estos casos contaban como validos.
    inventados = [r for r in results if "unknown_argument" in (r.get("error_kinds") or [])]
    print(f"\n[INFO] prompts con argumentos inventados: {len(inventados)}")
    for r in inventados[:10]:
        print(f"  - [{r['mcp']}] {r['prompt'][:90]} -> {r['errors']}")

    with open(RESULTS_PATH, "w", encoding="utf-8") as f:
        json.dump({"stats": stats, "results": results}, f, ensure_ascii=False, indent=2)
    print(f"\n[INFO] resultados detallados en {RESULTS_PATH}")


if __name__ == "__main__":
    main()