vllm_nanoclaw_runtime/cli.py

from __future__ import annotations

import argparse
import sys
from pathlib import Path
from typing import Any

from .backend import build_llm, build_sampling_params, load_tokenizer
from .runner import iter_jsonl_results, run_task, run_tasks_batched, utc_now, write_summary
from .tasks import discover_tasks


def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Run Nanoclaw-compatible workplace tasks with a local vLLM model.",
        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
    )
    parser.add_argument("--base-tasks", required=True, help="Input base_tasks directory.")
    parser.add_argument("--output", required=True, help="Output result root directory.")
    parser.add_argument("--model", required=True, help="Local model path or model name for vLLM.")
    parser.add_argument("--tokenizer", default=None, help="Tokenizer path; defaults to --model.")
    parser.add_argument(
        "--task-id",
        action="append",
        default=None,
        help="Run only this task id. Can be specified multiple times.",
    )
    parser.add_argument("--task-glob", default="data_*", help="Task directory glob under base_tasks/tasks.")
    parser.add_argument("--overwrite", action="store_true", help="Overwrite existing task result dirs.")
    parser.add_argument("--resume", action="store_true", help="Skip completed task result dirs.")
    parser.add_argument("--run-verifier", action="store_true", help="Run copied verify_workplace.py after inference.")
    parser.add_argument("--verifier-timeout", type=float, default=120.0, help="Verifier timeout in seconds.")

    thinking = parser.add_mutually_exclusive_group()
    thinking.add_argument("--enable-thinking", dest="enable_thinking", action="store_true")
    thinking.add_argument("--disable-thinking", dest="enable_thinking", action="store_false")
    parser.set_defaults(enable_thinking=False)

    parser.add_argument("--tensor-parallel-size", type=int, default=1)
    parser.add_argument("--dtype", default="bfloat16", choices=("auto", "float16", "bfloat16", "float32"))
    parser.add_argument("--max-model-len", type=int, default=8192)
    parser.add_argument("--max-num-batched-tokens", type=int, default=None)
    parser.add_argument("--max-num-seqs", type=int, default=None)
    parser.add_argument("--gpu-memory-utilization", type=float, default=0.85)
    parser.add_argument("--trust-remote-code", action=argparse.BooleanOptionalAction, default=True)
    parser.add_argument("--enforce-eager", action="store_true")
    parser.add_argument("--enable-prefix-caching", action="store_true")

    parser.add_argument("--max-steps", type=int, default=20, help="Maximum agent/tool turns per task.")
    parser.add_argument(
        "--agent-batch-size",
        type=int,
        default=1,
        help="Number of active tasks to advance in each vLLM.generate batch.",
    )
    parser.add_argument("--max-tokens", type=int, default=2048, help="Maximum generated tokens per turn.")
    parser.add_argument("--temperature", type=float, default=0.2)
    parser.add_argument("--top-p", type=float, default=0.95)
    parser.add_argument("--top-k", type=int, default=-1)
    parser.add_argument("--seed", type=int, default=None)
    parser.add_argument("--read-limit", type=int, default=24000, help="Maximum characters returned by read.")
    parser.add_argument("--list-limit", type=int, default=500, help="Maximum entries returned by ls/find/grep.")
    parser.add_argument("--allow-python-tool", action="store_true", help="Enable model generated Python execution.")
    parser.add_argument("--python-timeout", type=float, default=20.0, help="run_python timeout in seconds.")
    args = parser.parse_args(argv)

    if args.max_steps <= 0:
        parser.error("--max-steps must be positive")
    if args.agent_batch_size <= 0:
        parser.error("--agent-batch-size must be positive")
    if args.resume and args.overwrite:
        parser.error("--resume and --overwrite are mutually exclusive")
    return args


def main(argv: list[str] | None = None) -> int:
    args = parse_args(argv)
    base_tasks = Path(args.base_tasks).expanduser().resolve()
    output_root = Path(args.output).expanduser().resolve()
    requested_task_ids = set(args.task_id) if args.task_id else None
    specs = discover_tasks(base_tasks, task_glob=args.task_glob, task_ids=requested_task_ids)

    print(f"[info] base_tasks={base_tasks}", file=sys.stderr)
    print(f"[info] output={output_root}", file=sys.stderr)
    print(f"[info] tasks={len(specs)}", file=sys.stderr)
    print(f"[info] model={args.model}", file=sys.stderr)
    print(f"[info] agent_batch_size={args.agent_batch_size}", file=sys.stderr)

    tokenizer = load_tokenizer(args)
    llm = build_llm(args)
    sampling_params = build_sampling_params(args)

    started_at = utc_now()
    results: list[dict[str, Any]] = []
    output_root.mkdir(parents=True, exist_ok=True)

    if args.agent_batch_size > 1 and len(specs) > 1:
        results = run_tasks_batched(
            specs=specs,
            result_root=output_root,
            llm=llm,
            tokenizer=tokenizer,
            sampling_params=sampling_params,
            args=args,
        )
        (output_root / "results.jsonl").write_text(iter_jsonl_results(results), encoding="utf-8")
        write_summary(output_root, results, started_at)
    else:
        for spec in specs:
            print(f"[task] {spec.task_id}", file=sys.stderr)
            try:
                result = run_task(
                    spec=spec,
                    result_root=output_root,
                    llm=llm,
                    tokenizer=tokenizer,
                    sampling_params=sampling_params,
                    args=args,
                )
            except Exception as exc:
                result = {
                    "task_id": spec.task_id,
                    "status": "failed",
                    "result_dir": str(output_root / spec.task_id),
                    "error": f"{type(exc).__name__}: {exc}",
                }
                print(f"[error] {spec.task_id}: {result['error']}", file=sys.stderr)
            results.append(result)
            (output_root / "results.jsonl").write_text(iter_jsonl_results(results), encoding="utf-8")
            write_summary(output_root, results, started_at)

    completed = sum(1 for result in results if result.get("status") == "completed")
    failed = sum(1 for result in results if result.get("status") == "failed")
    skipped = sum(1 for result in results if result.get("status") == "skipped")
    print(f"[done] completed={completed} failed={failed} skipped={skipped} output={output_root}", file=sys.stderr)
    return 1 if failed else 0


if __name__ == "__main__":
    raise SystemExit(main())