File size: 6,841 Bytes
f03667b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
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())