agent-trace

"""Batch trace collection from MBPP and NL2Bash datasets."""

import argparse
import os
import re
import sys
import time
from pathlib import Path

from datasets import load_dataset
from smolagents import OpenAIServerModel, PythonInterpreterTool, ToolCallingAgent

from src.instrumentation import instrument_model, instrument_tools
from src.run_metadata import (
    build_run_id,
    build_trace_metadata,
    normalize_chat_template,
    normalize_server_args,
    write_run_manifest,
)
from src.tools import BashTool, VIRTUAL_TESTDATA_ROOT
from src.tracing import TraceCollector

# Defaults
MODEL_ID = "Qwen/Qwen3-0.6B"
API_BASE = "http://127.0.0.1:8080/v1"
OUTPUT_PATH = "datasets/traces.jsonl"
TESTDATA = Path(__file__).parent / "testdata"
DEFAULT_CONTEXT_LENGTH = int(os.getenv("LLAMA_CTX", "16384"))
DEFAULT_CHAT_TEMPLATE = os.getenv("LLAMA_CHAT_TEMPLATE_FILE")
DEFAULT_MODEL_ARTIFACT = os.getenv("LLAMA_MODEL")
DEFAULT_QUANTIZATION = os.getenv("TRACE_MODEL_QUANTIZATION")
DEFAULT_SERVING_ENGINE = os.getenv("TRACE_SERVING_ENGINE", "llama.cpp")
DEFAULT_SERVING_ENGINE_VERSION = os.getenv("TRACE_SERVING_ENGINE_VERSION")
DEFAULT_N_GPU_LAYERS = os.getenv("LLAMA_N_GPU_LAYERS")
DEFAULT_TEMPERATURE = os.getenv("TRACE_TEMPERATURE")
DEFAULT_TOP_P = os.getenv("TRACE_TOP_P")
DEFAULT_JINJA = os.getenv("LLAMA_JINJA")
DEFAULT_FLASH_ATTN = os.getenv("LLAMA_FLASH_ATTN")

DATASET_CONFIG = {
    "mbpp": {
        "split": "test",
        "prompt_sanitization_version": "none",
        "fixture_dir": None,
    },
    "nl2bash": {
        "split": "train",
        "prompt_sanitization_version": "virtual-testdata-root-v2",
        "fixture_dir": TESTDATA,
    },
}


# ── Dataset loaders ──────────────────────────────────────────────────────────

def load_mbpp(n: int, offset: int) -> list[dict]:
    """Load MBPP samples as [{id, prompt, source}]."""
    ds = load_dataset("google-research-datasets/mbpp", split="test")
    end = min(offset + n, len(ds))
    samples = ds.select(range(offset, end))
    results = []
    for s in samples:
        prompt = s["text"]
        tests = s["test_list"]
        if tests:
            prompt += "\n\nTest cases:\n" + "\n".join(tests)
        results.append({"id": s["task_id"], "prompt": prompt, "source": "mbpp"})
    return results


def load_nl2bash(n: int, offset: int) -> list[dict]:
    """Load NL2Bash samples, rewriting paths to the virtual /testdata root."""
    ds = load_dataset("epinnock/intercode-nl2bash-curated", split="train")
    end = min(offset + n, len(ds))
    samples = ds.select(range(offset, end))
    results = []
    for i, s in enumerate(samples):
        query = s["query"]
        # Rewrite fixture paths to a stable virtual root to avoid leaking host paths.
        query = re.sub(r"(?<!')/(system|testbed|workspace)\b", rf"{VIRTUAL_TESTDATA_ROOT}/\1", query)
        query = re.sub(r"'/(system|testbed|workspace)\b", rf"'{VIRTUAL_TESTDATA_ROOT}/\1", query)
        prompt = (
            f"{query}\n\n"
            f"Use the bash tool to execute the command. "
            f"The files are located under {VIRTUAL_TESTDATA_ROOT}/."
        )
        results.append({"id": offset + i, "prompt": prompt, "source": "nl2bash"})
    return results


DATASET_LOADERS = {
    "mbpp": load_mbpp,
    "nl2bash": load_nl2bash,
}


# ── Trace collection ─────────────────────────────────────────────────────────

def collect_trace(
    agent: ToolCallingAgent,
    prompt: str,
    model_id: str,
    output_path: str,
    base_metadata: dict | None = None,
    source: str = "unknown",
    task_id: int | None = None,
) -> bool:
    """Run one prompt through the agent and save the trace. Returns True on success."""
    collector = TraceCollector(prompt=prompt, model=model_id)
    collector.extra_metadata = dict(base_metadata or {})
    collector.extra_metadata["source"] = source
    if task_id is not None:
        collector.extra_metadata["task_id"] = task_id

    # Re-instrument tools and model with the new collector
    tools = list(agent.tools.values())
    instrument_tools(tools, collector)
    instrument_model(agent.model, collector)

    collector.start()
    result = None
    try:
        result = agent.run(prompt, return_full_result=True)
    except Exception as e:
        print(f"  Agent error: {e}", file=sys.stderr)

    collector.stop()

    if result:
        collector.record_llm_steps_from_result(result)

    collector.save(output_path)
    return result is not None


def main():
    parser = argparse.ArgumentParser(description="Collect traces from HF datasets")
    parser.add_argument("-n", type=int, default=100, help="Number of prompts to run")
    parser.add_argument("--offset", type=int, default=0, help="Start index in dataset")
    parser.add_argument("--dataset", type=str, default="mbpp",
                        choices=list(DATASET_LOADERS.keys()),
                        help="Dataset to use")
    parser.add_argument("--output", type=str, default=OUTPUT_PATH)
    parser.add_argument(
        "--append",
        action="store_true",
        help="Append to an existing output file instead of overwriting it",
    )
    parser.add_argument("--run-id", type=str, help="Optional stable identifier for this collection run")
    parser.add_argument("--model", type=str, default=MODEL_ID)
    parser.add_argument("--model-artifact", type=str, default=DEFAULT_MODEL_ARTIFACT)
    parser.add_argument("--quantization", type=str, default=DEFAULT_QUANTIZATION)
    parser.add_argument("--api-base", type=str, default=API_BASE)
    parser.add_argument("--tool-choice", type=str, default="auto", help="OpenAI tool_choice setting")
    parser.add_argument("--context-length", type=int, default=DEFAULT_CONTEXT_LENGTH)
    parser.add_argument("--chat-template", type=str, default=DEFAULT_CHAT_TEMPLATE)
    parser.add_argument("--serving-engine", type=str, default=DEFAULT_SERVING_ENGINE)
    parser.add_argument("--serving-engine-version", type=str, default=DEFAULT_SERVING_ENGINE_VERSION)
    parser.add_argument(
        "--jinja",
        action=argparse.BooleanOptionalAction,
        default=None if DEFAULT_JINJA is None else DEFAULT_JINJA.lower() in {"1", "true", "yes", "on"},
        help="Whether llama-server was started with --jinja",
    )
    parser.add_argument(
        "--flash-attn",
        action=argparse.BooleanOptionalAction,
        default=None if DEFAULT_FLASH_ATTN is None else DEFAULT_FLASH_ATTN.lower() in {"1", "true", "yes", "on"},
        help="Whether llama-server was started with --flash-attn",
    )
    parser.add_argument(
        "--n-gpu-layers",
        type=int,
        default=int(DEFAULT_N_GPU_LAYERS) if DEFAULT_N_GPU_LAYERS else None,
        help="Normalized llama.cpp n_gpu_layers setting",
    )
    parser.add_argument(
        "--temperature",
        type=float,
        default=float(DEFAULT_TEMPERATURE) if DEFAULT_TEMPERATURE else None,
        help="Sampling temperature used by the serving stack",
    )
    parser.add_argument(
        "--top-p",
        type=float,
        default=float(DEFAULT_TOP_P) if DEFAULT_TOP_P else None,
        help="Sampling top_p used by the serving stack",
    )
    parser.add_argument("--max-steps", type=int, default=10, help="Max agent steps per prompt")
    args = parser.parse_args()

    repo_root = Path(__file__).resolve().parent
    output_path = Path(args.output)
    if output_path.exists():
        if args.append:
            print(f"Appending to existing output: {output_path}")
        else:
            output_path.unlink()
            print(f"Overwriting existing output: {output_path}")
    else:
        print(f"Writing new output: {output_path}")

    dataset_cfg = DATASET_CONFIG[args.dataset]
    run_id = args.run_id or build_run_id(args.dataset)
    server_args_normalized = normalize_server_args(
        api_base=args.api_base,
        tool_choice=args.tool_choice,
        context_length=args.context_length,
        chat_template=normalize_chat_template(args.chat_template),
        jinja=args.jinja,
        flash_attn=args.flash_attn,
        n_gpu_layers=args.n_gpu_layers,
        temperature=args.temperature,
        top_p=args.top_p,
    )
    base_metadata = build_trace_metadata(
        repo_root=repo_root,
        run_id=run_id,
        model_id=args.model,
        api_base=args.api_base,
        model_artifact=args.model_artifact,
        quantization=args.quantization,
        serving_engine=args.serving_engine,
        serving_engine_version=args.serving_engine_version,
        tool_choice=args.tool_choice,
        context_length=args.context_length,
        max_steps=args.max_steps,
        dataset_name=args.dataset,
        dataset_split=dataset_cfg["split"],
        dataset_offset=args.offset,
        chat_template=args.chat_template,
        prompt_sanitization_version=dataset_cfg["prompt_sanitization_version"],
        fixture_dir=dataset_cfg["fixture_dir"],
        server_args_normalized=server_args_normalized,
    )
    manifest_path = write_run_manifest(
        repo_root=repo_root,
        run_id=run_id,
        trace_metadata=base_metadata,
        output_path=output_path,
        raw_command=[sys.executable, *sys.argv],
    )
    print(f"Run ID: {run_id}")
    print(f"Run manifest: {manifest_path}")

    # Load dataset
    print(f"Loading {args.dataset} dataset...")
    loader = DATASET_LOADERS[args.dataset]
    samples = loader(args.n, args.offset)
    print(f"Selected {len(samples)} prompts (offset={args.offset})")

    # Initialize model + agent once
    model = OpenAIServerModel(
        model_id=args.model,
        api_base=args.api_base,
        api_key="not-needed",
        tool_choice=args.tool_choice,
    )
    # Sandbox BashTool to testdata/ for NL2Bash to prevent filesystem damage
    bash_tool = BashTool(allowed_dir=TESTDATA) if args.dataset == "nl2bash" else BashTool()
    agent = ToolCallingAgent(
        tools=[PythonInterpreterTool(), bash_tool],
        model=model,
        max_steps=args.max_steps,
    )

    # Collect traces
    success = 0
    total = len(samples)
    t0 = time.time()

    for i, sample in enumerate(samples):
        print(f"[{i+1}/{total}] {sample['source']}#{sample['id']}: {sample['prompt'][:80]}...")

        ok = collect_trace(
            agent, sample["prompt"], args.model, output_path,
            base_metadata=base_metadata,
            source=sample["source"], task_id=sample["id"],
        )
        if ok:
            success += 1
        status = "OK" if ok else "FAIL"
        print(f"  {status} ({success}/{i+1} successful)")

    elapsed = time.time() - t0
    print(f"\nDone: {success}/{total} traces in {elapsed:.1f}s")
    print(f"Output: {output_path}")


if __name__ == "__main__":
    main()

	"""Batch trace collection from MBPP and NL2Bash datasets."""

	import argparse
	import os
	import re
	import sys
	import time
	from pathlib import Path

	from datasets import load_dataset
	from smolagents import OpenAIServerModel, PythonInterpreterTool, ToolCallingAgent

	from src.instrumentation import instrument_model, instrument_tools
	from src.run_metadata import (
	build_run_id,
	build_trace_metadata,
	normalize_chat_template,
	normalize_server_args,
	write_run_manifest,
	)
	from src.tools import BashTool, VIRTUAL_TESTDATA_ROOT
	from src.tracing import TraceCollector

	# Defaults
	MODEL_ID = "Qwen/Qwen3-0.6B"
	API_BASE = "http://127.0.0.1:8080/v1"
	OUTPUT_PATH = "datasets/traces.jsonl"
	TESTDATA = Path(__file__).parent / "testdata"
	DEFAULT_CONTEXT_LENGTH = int(os.getenv("LLAMA_CTX", "16384"))
	DEFAULT_CHAT_TEMPLATE = os.getenv("LLAMA_CHAT_TEMPLATE_FILE")
	DEFAULT_MODEL_ARTIFACT = os.getenv("LLAMA_MODEL")
	DEFAULT_QUANTIZATION = os.getenv("TRACE_MODEL_QUANTIZATION")
	DEFAULT_SERVING_ENGINE = os.getenv("TRACE_SERVING_ENGINE", "llama.cpp")
	DEFAULT_SERVING_ENGINE_VERSION = os.getenv("TRACE_SERVING_ENGINE_VERSION")
	DEFAULT_N_GPU_LAYERS = os.getenv("LLAMA_N_GPU_LAYERS")
	DEFAULT_TEMPERATURE = os.getenv("TRACE_TEMPERATURE")
	DEFAULT_TOP_P = os.getenv("TRACE_TOP_P")
	DEFAULT_JINJA = os.getenv("LLAMA_JINJA")
	DEFAULT_FLASH_ATTN = os.getenv("LLAMA_FLASH_ATTN")

	DATASET_CONFIG = {
	"mbpp": {
	"split": "test",
	"prompt_sanitization_version": "none",
	"fixture_dir": None,
	},
	"nl2bash": {
	"split": "train",
	"prompt_sanitization_version": "virtual-testdata-root-v2",
	"fixture_dir": TESTDATA,
	},
	}


	# ── Dataset loaders ──────────────────────────────────────────────────────────

	def load_mbpp(n: int, offset: int) -> list[dict]:
	"""Load MBPP samples as [{id, prompt, source}]."""
	ds = load_dataset("google-research-datasets/mbpp", split="test")
	end = min(offset + n, len(ds))
	samples = ds.select(range(offset, end))
	results = []
	for s in samples:
	prompt = s["text"]
	tests = s["test_list"]
	if tests:
	prompt += "\n\nTest cases:\n" + "\n".join(tests)
	results.append({"id": s["task_id"], "prompt": prompt, "source": "mbpp"})
	return results


	def load_nl2bash(n: int, offset: int) -> list[dict]:
	"""Load NL2Bash samples, rewriting paths to the virtual /testdata root."""
	ds = load_dataset("epinnock/intercode-nl2bash-curated", split="train")
	end = min(offset + n, len(ds))
	samples = ds.select(range(offset, end))
	results = []
	for i, s in enumerate(samples):
	query = s["query"]
	# Rewrite fixture paths to a stable virtual root to avoid leaking host paths.
	query = re.sub(r"(?<!')/(system\|testbed\|workspace)\b", rf"{VIRTUAL_TESTDATA_ROOT}/\1", query)
	query = re.sub(r"'/(system\|testbed\|workspace)\b", rf"'{VIRTUAL_TESTDATA_ROOT}/\1", query)
	prompt = (
	f"{query}\n\n"
	f"Use the bash tool to execute the command. "
	f"The files are located under {VIRTUAL_TESTDATA_ROOT}/."
	)
	results.append({"id": offset + i, "prompt": prompt, "source": "nl2bash"})
	return results


	DATASET_LOADERS = {
	"mbpp": load_mbpp,
	"nl2bash": load_nl2bash,
	}


	# ── Trace collection ─────────────────────────────────────────────────────────

	def collect_trace(
	agent: ToolCallingAgent,
	prompt: str,
	model_id: str,
	output_path: str,
	base_metadata: dict \| None = None,
	source: str = "unknown",
	task_id: int \| None = None,
	) -> bool:
	"""Run one prompt through the agent and save the trace. Returns True on success."""
	collector = TraceCollector(prompt=prompt, model=model_id)
	collector.extra_metadata = dict(base_metadata or {})
	collector.extra_metadata["source"] = source
	if task_id is not None:
	collector.extra_metadata["task_id"] = task_id

	# Re-instrument tools and model with the new collector
	tools = list(agent.tools.values())
	instrument_tools(tools, collector)
	instrument_model(agent.model, collector)

	collector.start()
	result = None
	try:
	result = agent.run(prompt, return_full_result=True)
	except Exception as e:
	print(f" Agent error: {e}", file=sys.stderr)

	collector.stop()

	if result:
	collector.record_llm_steps_from_result(result)

	collector.save(output_path)
	return result is not None


	def main():
	parser = argparse.ArgumentParser(description="Collect traces from HF datasets")
	parser.add_argument("-n", type=int, default=100, help="Number of prompts to run")
	parser.add_argument("--offset", type=int, default=0, help="Start index in dataset")
	parser.add_argument("--dataset", type=str, default="mbpp",
	choices=list(DATASET_LOADERS.keys()),
	help="Dataset to use")
	parser.add_argument("--output", type=str, default=OUTPUT_PATH)
	parser.add_argument(
	"--append",
	action="store_true",
	help="Append to an existing output file instead of overwriting it",
	)
	parser.add_argument("--run-id", type=str, help="Optional stable identifier for this collection run")
	parser.add_argument("--model", type=str, default=MODEL_ID)
	parser.add_argument("--model-artifact", type=str, default=DEFAULT_MODEL_ARTIFACT)
	parser.add_argument("--quantization", type=str, default=DEFAULT_QUANTIZATION)
	parser.add_argument("--api-base", type=str, default=API_BASE)
	parser.add_argument("--tool-choice", type=str, default="auto", help="OpenAI tool_choice setting")
	parser.add_argument("--context-length", type=int, default=DEFAULT_CONTEXT_LENGTH)
	parser.add_argument("--chat-template", type=str, default=DEFAULT_CHAT_TEMPLATE)
	parser.add_argument("--serving-engine", type=str, default=DEFAULT_SERVING_ENGINE)
	parser.add_argument("--serving-engine-version", type=str, default=DEFAULT_SERVING_ENGINE_VERSION)
	parser.add_argument(
	"--jinja",
	action=argparse.BooleanOptionalAction,
	default=None if DEFAULT_JINJA is None else DEFAULT_JINJA.lower() in {"1", "true", "yes", "on"},
	help="Whether llama-server was started with --jinja",
	)
	parser.add_argument(
	"--flash-attn",
	action=argparse.BooleanOptionalAction,
	default=None if DEFAULT_FLASH_ATTN is None else DEFAULT_FLASH_ATTN.lower() in {"1", "true", "yes", "on"},
	help="Whether llama-server was started with --flash-attn",
	)
	parser.add_argument(
	"--n-gpu-layers",
	type=int,
	default=int(DEFAULT_N_GPU_LAYERS) if DEFAULT_N_GPU_LAYERS else None,
	help="Normalized llama.cpp n_gpu_layers setting",
	)
	parser.add_argument(
	"--temperature",
	type=float,
	default=float(DEFAULT_TEMPERATURE) if DEFAULT_TEMPERATURE else None,
	help="Sampling temperature used by the serving stack",
	)
	parser.add_argument(
	"--top-p",
	type=float,
	default=float(DEFAULT_TOP_P) if DEFAULT_TOP_P else None,
	help="Sampling top_p used by the serving stack",
	)
	parser.add_argument("--max-steps", type=int, default=10, help="Max agent steps per prompt")
	args = parser.parse_args()

	repo_root = Path(__file__).resolve().parent
	output_path = Path(args.output)
	if output_path.exists():
	if args.append:
	print(f"Appending to existing output: {output_path}")
	else:
	output_path.unlink()
	print(f"Overwriting existing output: {output_path}")
	else:
	print(f"Writing new output: {output_path}")

	dataset_cfg = DATASET_CONFIG[args.dataset]
	run_id = args.run_id or build_run_id(args.dataset)
	server_args_normalized = normalize_server_args(
	api_base=args.api_base,
	tool_choice=args.tool_choice,
	context_length=args.context_length,
	chat_template=normalize_chat_template(args.chat_template),
	jinja=args.jinja,
	flash_attn=args.flash_attn,
	n_gpu_layers=args.n_gpu_layers,
	temperature=args.temperature,
	top_p=args.top_p,
	)
	base_metadata = build_trace_metadata(
	repo_root=repo_root,
	run_id=run_id,
	model_id=args.model,
	api_base=args.api_base,
	model_artifact=args.model_artifact,
	quantization=args.quantization,
	serving_engine=args.serving_engine,
	serving_engine_version=args.serving_engine_version,
	tool_choice=args.tool_choice,
	context_length=args.context_length,
	max_steps=args.max_steps,
	dataset_name=args.dataset,
	dataset_split=dataset_cfg["split"],
	dataset_offset=args.offset,
	chat_template=args.chat_template,
	prompt_sanitization_version=dataset_cfg["prompt_sanitization_version"],
	fixture_dir=dataset_cfg["fixture_dir"],
	server_args_normalized=server_args_normalized,
	)
	manifest_path = write_run_manifest(
	repo_root=repo_root,
	run_id=run_id,
	trace_metadata=base_metadata,
	output_path=output_path,
	raw_command=[sys.executable, *sys.argv],
	)
	print(f"Run ID: {run_id}")
	print(f"Run manifest: {manifest_path}")

	# Load dataset
	print(f"Loading {args.dataset} dataset...")
	loader = DATASET_LOADERS[args.dataset]
	samples = loader(args.n, args.offset)
	print(f"Selected {len(samples)} prompts (offset={args.offset})")

	# Initialize model + agent once
	model = OpenAIServerModel(
	model_id=args.model,
	api_base=args.api_base,
	api_key="not-needed",
	tool_choice=args.tool_choice,
	)
	# Sandbox BashTool to testdata/ for NL2Bash to prevent filesystem damage
	bash_tool = BashTool(allowed_dir=TESTDATA) if args.dataset == "nl2bash" else BashTool()
	agent = ToolCallingAgent(
	tools=[PythonInterpreterTool(), bash_tool],
	model=model,
	max_steps=args.max_steps,
	)

	# Collect traces
	success = 0
	total = len(samples)
	t0 = time.time()

	for i, sample in enumerate(samples):
	print(f"[{i+1}/{total}] {sample['source']}#{sample['id']}: {sample['prompt'][:80]}...")

	ok = collect_trace(
	agent, sample["prompt"], args.model, output_path,
	base_metadata=base_metadata,
	source=sample["source"], task_id=sample["id"],
	)
	if ok:
	success += 1
	status = "OK" if ok else "FAIL"
	print(f" {status} ({success}/{i+1} successful)")

	elapsed = time.time() - t0
	print(f"\nDone: {success}/{total} traces in {elapsed:.1f}s")
	print(f"Output: {output_path}")


	if __name__ == "__main__":
	main()