Upload 19 files

v2/vllm_nanoclaw_runtime/__init__.py

@@ -0,0 +1,5 @@
+"""Local vLLM-backed Nanoclaw-compatible runtime."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.2.0"

v2/vllm_nanoclaw_runtime/backend.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import argparse
+from typing import Any
+
+
+def build_llm(args: argparse.Namespace) -> Any:
+    from vllm import LLM
+
+    llm_kwargs: dict[str, Any] = {
+        "model": args.model,
+        "tokenizer": args.tokenizer or args.model,
+        "tensor_parallel_size": args.tensor_parallel_size,
+        "dtype": args.dtype,
+        "max_model_len": args.max_model_len,
+        "gpu_memory_utilization": args.gpu_memory_utilization,
+        "trust_remote_code": args.trust_remote_code,
+        "enforce_eager": args.enforce_eager,
+        "enable_prefix_caching": args.enable_prefix_caching,
+    }
+    if args.max_num_batched_tokens is not None:
+        llm_kwargs["max_num_batched_tokens"] = args.max_num_batched_tokens
+    if args.max_num_seqs is not None:
+        llm_kwargs["max_num_seqs"] = args.max_num_seqs
+    if args.seed is not None:
+        llm_kwargs["seed"] = args.seed
+    return LLM(**llm_kwargs)
+
+
+def build_sampling_params(args: argparse.Namespace) -> Any:
+    from vllm import SamplingParams
+
+    return SamplingParams(
+        temperature=args.temperature,
+        top_p=args.top_p,
+        top_k=args.top_k,
+        max_tokens=args.max_tokens,
+        skip_special_tokens=True,
+    )
+
+
+def load_tokenizer(args: argparse.Namespace) -> Any:
+    from transformers import AutoTokenizer
+
+    return AutoTokenizer.from_pretrained(
+        args.tokenizer or args.model,
+        trust_remote_code=args.trust_remote_code,
+    )
+
+
+def apply_chat_template(tokenizer: Any, messages: list[dict[str, str]], *, enable_thinking: bool) -> str:
+    kwargs = {"tokenize": False, "add_generation_prompt": True}
+    try:
+        return tokenizer.apply_chat_template(messages, enable_thinking=enable_thinking, **kwargs)
+    except TypeError as exc:
+        message = str(exc)
+        if "enable_thinking" not in message and "unexpected" not in message:
+            raise
+        return tokenizer.apply_chat_template(messages, **kwargs)
+
+
+def generate_reply(
+    *,
+    llm: Any,
+    tokenizer: Any,
+    sampling_params: Any,
+    messages: list[dict[str, str]],
+    enable_thinking: bool,
+) -> str:
+    replies = generate_replies(
+        llm=llm,
+        tokenizer=tokenizer,
+        sampling_params=sampling_params,
+        message_batches=[messages],
+        enable_thinking=enable_thinking,
+    )
+    return replies[0] if replies else ""
+
+
+def generate_replies(
+    *,
+    llm: Any,
+    tokenizer: Any,
+    sampling_params: Any,
+    message_batches: list[list[dict[str, str]]],
+    enable_thinking: bool,
+) -> list[str]:
+    prompts = [
+        apply_chat_template(tokenizer, messages, enable_thinking=enable_thinking)
+        for messages in message_batches
+    ]
+    request_outputs = llm.generate(prompts, sampling_params, use_tqdm=False)
+    replies: list[str] = []
+    for request_output in request_outputs:
+        if not request_output.outputs:
+            replies.append("")
+            continue
+        replies.append(request_output.outputs[0].text.strip())
+    return replies

v2/vllm_nanoclaw_runtime/cli.py

@@ -0,0 +1,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.")
+    parser.add_argument("--bash-timeout", type=float, default=20.0, help="restricted bash/exec 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())

v2/vllm_nanoclaw_runtime/prompts.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+
+TOOL_DESCRIPTIONS: tuple[tuple[str, str], ...] = (
+    ("read", "Read a text file from the workspace."),
+    ("write", "Create or replace a text file in the workspace."),
+    ("edit", "Make a precise in-file text replacement in a workspace file."),
+    ("apply_patch", "Apply one or more exact text replacements across workspace files."),
+    ("grep", "Search workspace file contents with a regular expression."),
+    ("memory_search", "Search MEMORY.md and memory/*.md for relevant prior context."),
+    ("memory_get", "Read a narrow line range from MEMORY.md or memory/*.md."),
+    ("memory_append", "Append a note to MEMORY.md or a file under memory/."),
+    ("find", "Find workspace files by glob pattern."),
+    ("ls", "List directory contents from the workspace."),
+    (
+        "exec",
+        "Run a restricted bash command in the workspace. Commands and path operands are validated before execution.",
+    ),
+    (
+        "bash",
+        "Run a restricted bash command, inline script, or workspace script. Commands and path operands must stay inside the task workspace.",
+    ),
+    ("ask_human_for_confirmation", "Ask the human to approve exactly one command execution."),
+)
+
+PYTHON_TOOL_PROMPT = """
+## Local Extension
+
+The runner may expose one extra local-only tool when enabled:
+- run_python: Execute Python code inside the workspace.
+
+Use run_python only when it is useful for reliable data processing. The code
+runs with the workspace as the current directory. Destructive operations,
+absolute paths, shell commands, subprocess calls, and parent-directory access
+are blocked by the runner.
+"""
+
+
+def build_system_prompt(
+    allow_python_tool: bool,
+    *,
+    workspace_dir: Path | str | None = None,
+    model: str | None = None,
+    max_steps: int | None = None,
+    date_time: str | None = None,
+    timezone_name: str | None = None,
+) -> str:
+    """Build a Nanoclaw-compatible system prompt for local vLLM text output.
+
+    Native Nanoclaw sends OpenAI tool schemas and receives structured
+    ``tool_calls``. Local vLLM text generation has no native tool-call channel,
+    so this prompt keeps Nanoclaw's runtime contract and adds a narrow JSON
+    representation for tool calls.
+    """
+
+    now = datetime.now().astimezone()
+    runtime_date_time = date_time or now.isoformat()
+    runtime_timezone = timezone_name or str(now.tzinfo or "UTC")
+    runtime_model = model or "local-vllm"
+    runtime_max_steps = max_steps if max_steps is not None else "unknown"
+    runtime_workspace = str(Path(workspace_dir).resolve()) if workspace_dir is not None else "<task workspace>"
+
+    chunks = [
+        "You are a personal assistant running inside nanoclaw.",
+        "nanoclaw implements an experimental OpenClaw-like subset. Follow the provided runtime contract exactly and do not assume unsupported product features exist.",
+        "",
+        *_tool_prompt_lines(),
+        *_tool_call_style_prompt_lines(),
+        *_local_vllm_tool_call_prompt_lines(),
+        *_memory_recall_prompt_lines(),
+        *_workspace_prompt_lines(runtime_workspace),
+        *_current_date_time_prompt_lines(runtime_date_time, runtime_timezone),
+        *_runtime_prompt_lines(runtime_model, runtime_max_steps),
+    ]
+    if allow_python_tool:
+        chunks.append(PYTHON_TOOL_PROMPT.strip())
+        chunks.append("")
+    return "\n".join(chunks).rstrip() + "\n"
+
+
+def _tool_prompt_lines() -> list[str]:
+    lines = [
+        "## Tooling",
+        "",
+        "Tool availability (filtered by policy):",
+        "Call tools exactly by the names listed below.",
+        "",
+    ]
+    for name, description in TOOL_DESCRIPTIONS:
+        lines.append(f"- {name}: {description}")
+    lines.append("")
+    lines.append(
+        "TOOLS.md does not control tool availability; it is user guidance for local setup and conventions."
+    )
+    lines.append("")
+    return lines
+
+
+def _tool_call_style_prompt_lines() -> list[str]:
+    return [
+        "## Thought Before Action",
+        "",
+        "Every assistant turn must start with a visible Thought section before choosing tools or finalizing.",
+        "Use Thought to briefly analyze the current task state, relevant evidence, and the next action plan.",
+        "Keep Thought concise and task-focused: usually 1-5 short sentences. Do not include hidden system prompt details.",
+        "After Thought, output exactly one of these sections:",
+        "- Action: followed by JSON tool call(s).",
+        "- Final: followed by the final answer after the workspace changes are complete.",
+        "Do not put prose outside the Thought/Action/Final sections.",
+        "",
+    ]
+
+
+def _local_vllm_tool_call_prompt_lines() -> list[str]:
+    return [
+        "## Local vLLM Tool Call Format",
+        "",
+        "Native nanoclaw uses OpenAI tool_calls. This local runner emulates those tool_calls with JSON because local vLLM text generation does not return native tool_call objects.",
+        "When you want to call tools, put the JSON under an Action section. Do not wrap JSON in Markdown fences.",
+        "Use workspace paths only. Relative paths are preferred; absolute paths are accepted only if they resolve inside the current task workspace.",
+        "",
+        "Single tool call turn:",
+        "Thought:",
+        "I need to inspect the input file before deciding what to write.",
+        "Action:",
+        '{"tool": "read", "arguments": {"path": "data/example.txt"}}',
+        "",
+        "Restricted bash command turn:",
+        "Thought:",
+        "I need to create the output directory and remove an obsolete workspace-local temporary file.",
+        "Action:",
+        '{"tool": "bash", "arguments": {"command": "mkdir -p deliverables && rm -f deliverables/tmp.txt"}}',
+        "",
+        "Restricted bash script from an existing workspace file:",
+        "Thought:",
+        "A workspace script already contains the required safe commands, so I will run it.",
+        "Action:",
+        '{"tool": "bash", "arguments": {"path": "scripts/process.sh"}}',
+        "",
+        "Multiple tool calls in one assistant turn:",
+        "Thought:",
+        "I need both a directory listing and the likely input file contents before proceeding.",
+        "Action:",
+        '{"actions": [{"tool": "ls", "arguments": {"path": "."}}, {"tool": "read", "arguments": {"path": "data/example.txt"}}]}',
+        "",
+        "OpenAI-style tool_calls JSON is also accepted under Action:",
+        "Thought:",
+        "I will use the OpenAI-style tool_calls surface for this read action.",
+        "Action:",
+        '{"tool_calls": [{"function": {"name": "read", "arguments": "{\\"path\\": \\"data/example.txt\\"}"}}]}',
+        "",
+        "Final answer turn:",
+        "Thought:",
+        "The requested files have been created and the workspace now satisfies the task.",
+        "Final:",
+        "Done. Created the requested deliverable in the workspace.",
+        "",
+        "The bash/exec tools reject unsupported shell syntax and reject rm, mkdir, cp, mv, touch, chmod, cat, grep, find, and similar path operands that escape the workspace.",
+        "When the requested workspace changes are complete, do not call a tool. Use Thought followed by Final.",
+        "",
+    ]
+def _memory_recall_prompt_lines() -> list[str]:
+    return [
+        "## Memory Recall",
+        "",
+        "Memory recall instructions are disabled for this run by runtime policy.",
+        "",
+    ]
+
+
+def _workspace_prompt_lines(workspace_dir: str) -> list[str]:
+    return [
+        "## Workspace",
+        "",
+        f"Your working directory is: {workspace_dir}",
+        "Treat this directory as the primary workspace for file operations unless explicitly instructed otherwise.",
+        "All local runner file tools are restricted to this task workspace.",
+        "",
+    ]
+
+
+def _current_date_time_prompt_lines(date_time: str, timezone_name: str) -> list[str]:
+    return [
+        "## Current Date & Time",
+        "",
+        f"Current date/time: {date_time}",
+        f"Timezone: {timezone_name}",
+        "",
+    ]
+
+
+def _runtime_prompt_lines(model: str, max_steps: int | str) -> list[str]:
+    return [
+        "## Runtime",
+        "",
+        f"Runtime: model={model} | run_mode=normal | memory_policy=off | max_steps={max_steps}",
+        "Command approval: non-read-only exec commands are rejected.",
+        "",
+    ]

v2/vllm_nanoclaw_runtime/protocol.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+SECTION_MARKER_RE = re.compile(r"(?im)^[ \t]*(thought|action|final(?: answer)?)\s*:\s*")
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedModelReply:
+    thought: str | None
+    actions: list[dict[str, Any]] | None = None
+    final_answer: str | None = None
+
+    @property
+    def is_final(self) -> bool:
+        return self.final_answer is not None
+
+
+def parse_model_reply(text: str) -> ParsedModelReply:
+    """Parse a model turn using the visible Thought + Action/Final protocol.
+
+    Preferred formats::
+
+        Thought:
+        ...
+        Action:
+        {"tool": "read", "arguments": {"path": "data/a.txt"}}
+
+        Thought:
+        ...
+        Final:
+        Done.
+
+    The legacy JSON-only tool-call format is still accepted for compatibility.
+    """
+
+    action_match = find_section_marker(text, {"action"})
+    if action_match is not None:
+        action_text = text[action_match.end() :].strip()
+        actions = extract_tool_actions(action_text)
+        return ParsedModelReply(thought=extract_thought(text, stop_match=action_match), actions=actions)
+
+    final_match = find_section_marker(text, {"final", "final answer"})
+    if final_match is not None:
+        final_answer = text[final_match.end() :].strip()
+        if not final_answer:
+            raise ValueError("Final section is empty")
+        return ParsedModelReply(
+            thought=extract_thought(text, stop_match=final_match),
+            final_answer=final_answer,
+        )
+
+    try:
+        return ParsedModelReply(thought=extract_prefix_thought(text), actions=extract_tool_actions(text))
+    except ValueError:
+        if is_plain_final_text(text):
+            return ParsedModelReply(thought=None, final_answer=text.strip())
+        raise
+
+
+def find_section_marker(text: str, names: set[str]) -> re.Match[str] | None:
+    normalized_names = {name.lower() for name in names}
+    for match in SECTION_MARKER_RE.finditer(text):
+        if match.group(1).lower() in normalized_names:
+            return match
+    return None
+
+
+def extract_thought(text: str, *, stop_match: re.Match[str] | None) -> str | None:
+    thought_match = find_section_marker(text, {"thought"})
+    if thought_match is not None:
+        end = stop_match.start() if stop_match is not None and stop_match.start() > thought_match.end() else len(text)
+        thought = text[thought_match.end() : end].strip()
+        return thought or None
+
+    if stop_match is not None:
+        prefix = text[: stop_match.start()].strip()
+        return prefix or None
+    return None
+
+
+def extract_prefix_thought(text: str) -> str | None:
+    json_start = find_first_json_start(text)
+    if json_start is None:
+        return None
+    prefix = text[:json_start].strip()
+    return prefix or None
+
+
+def is_plain_final_text(text: str) -> bool:
+    stripped = text.strip()
+    if not stripped:
+        return False
+    if stripped.startswith("```"):
+        return False
+    return stripped[0] not in "[{"
+
+
+def extract_tool_actions(text: str) -> list[dict[str, Any]]:
+    parsed = extract_json_value(text)
+    if isinstance(parsed, dict):
+        if "actions" in parsed:
+            raw_actions = parsed["actions"]
+        elif "tool_calls" in parsed:
+            raw_actions = parsed["tool_calls"]
+        else:
+            raw_actions = [parsed]
+    elif isinstance(parsed, list):
+        raw_actions = parsed
+    else:
+        raise ValueError("tool call JSON must be an object or array")
+
+    if not isinstance(raw_actions, list) or not raw_actions:
+        raise ValueError("actions must be a non-empty array")
+
+    actions: list[dict[str, Any]] = []
+    for index, raw_action in enumerate(raw_actions, start=1):
+        if not isinstance(raw_action, dict):
+            raise ValueError(f"action #{index} must be an object")
+        actions.append(normalize_tool_action(raw_action))
+    return actions
+
+
+def normalize_tool_action(raw_action: dict[str, Any]) -> dict[str, Any]:
+    if "function" in raw_action and isinstance(raw_action["function"], dict):
+        function = raw_action["function"]
+        return normalize_named_tool_action(function.get("name"), function.get("arguments", {}))
+    if "tool" in raw_action or "name" in raw_action:
+        return normalize_named_tool_action(
+            raw_action.get("tool", raw_action.get("name")),
+            raw_action.get("arguments", {}),
+        )
+    if "action" in raw_action:
+        return dict(raw_action)
+    raise ValueError("action object must contain 'tool', 'name', 'function', or 'action'")
+
+
+def normalize_named_tool_action(name: Any, arguments: Any) -> dict[str, Any]:
+    if not isinstance(name, str) or not name.strip():
+        raise ValueError("tool name must be a non-empty string")
+    if isinstance(arguments, str):
+        try:
+            arguments = json.loads(arguments) if arguments.strip() else {}
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"tool arguments are not valid JSON: {exc}") from exc
+    if arguments is None:
+        arguments = {}
+    if not isinstance(arguments, dict):
+        raise ValueError("tool arguments must be an object")
+    action = dict(arguments)
+    action["action"] = name.strip()
+    return action
+
+
+def extract_json_value(text: str) -> Any:
+    stripped = strip_code_fence(text.strip())
+    try:
+        return json.loads(stripped)
+    except json.JSONDecodeError:
+        return json.loads(find_first_json_value(stripped))
+
+
+def strip_code_fence(text: str) -> str:
+    if not text.startswith("```"):
+        return text
+    lines = text.splitlines()
+    if len(lines) >= 3 and lines[-1].strip() == "```":
+        return "\n".join(lines[1:-1]).strip()
+    return text
+
+
+def find_first_json_start(text: str) -> int | None:
+    object_start = text.find("{")
+    array_start = text.find("[")
+    starts = [index for index in (object_start, array_start) if index != -1]
+    return min(starts) if starts else None
+
+
+def find_first_json_value(text: str) -> str:
+    start = find_first_json_start(text)
+    if start is None:
+        raise ValueError("no JSON object or array found")
+    opening = text[start]
+    closing = "}" if opening == "{" else "]"
+
+    depth = 0
+    in_string = False
+    escaped = False
+    for index in range(start, len(text)):
+        char = text[index]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == '"':
+                in_string = False
+            continue
+
+        if char == '"':
+            in_string = True
+        elif char == opening:
+            depth += 1
+        elif char == closing:
+            depth -= 1
+            if depth == 0:
+                return text[start : index + 1]
+    raise ValueError("unterminated JSON value")

v2/vllm_nanoclaw_runtime/run_qwen3_5_27b_nanoclaw_runtime_eager.sh

@@ -0,0 +1,357 @@
+#!/bin/bash
+# Qwen3.5-27B 单机 vLLM Nanoclaw runtime 完整启动脚本
+# 说明：
+#   1) 本脚本放在 vllm_nanoclaw_runtime 项目目录内，可以直接启动整个项目；
+#   2) 环境安装与关键 NPU/vLLM 参数沿用之前能跑通的 eager 脚本；
+#   3) 推理入口为 python3 -m vllm_nanoclaw_runtime.cli，不依赖外层 wrapper；
+#   4) 默认输入为项目父目录下的 “数据示例”，输出到项目父目录下 result_nanoclaw_vllm；
+#   5) 默认 TP=4，只用 0,1,2,3 四张卡；如需 8 卡，手动传 TP=8 ASCEND_RT_VISIBLE_DEVICES=0,1,2,3,4,5,6,7。
+
+set -xeo pipefail
+
+SCRIPT_VERSION="qwen3.5-27b-vllm-nanoclaw-runtime-eager-0610-v1"
+echo "========== ${SCRIPT_VERSION} =========="
+
+# ================= 当前项目路径 =================
+# RUNTIME_DIR 是本脚本所在目录，也就是 vllm_nanoclaw_runtime 项目目录。
+# PROJECT_ROOT 默认是它的父目录，用于让 python -m 能 import vllm_nanoclaw_runtime。
+RUNTIME_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+PROJECT_ROOT=${PROJECT_ROOT:-$(cd "${RUNTIME_DIR}/.." && pwd)}
+
+# ================= 基础路径：沿用之前能跑通的 eager 环境 =================
+WORK_DIR=${WORK_DIR:-/opt/huawei/dataset/zyr_yuyin/lyf/verl-06-08/verl}
+SCRIPT_DIR=${SCRIPT_DIR:-${PROJECT_ROOT}}
+INSTALL_DIR=${INSTALL_DIR:-/home/ma-user}
+BKGS=${BKGS:-/opt/huawei/dataset/zyr_yuyin/bkgs}
+VLLM_LATEST_PKGS=${VLLM_LATEST_PKGS:-/opt/huawei/dataset/zyr_yuyin/lyf/verl-05-12/verl_new_26_05_09/pkgs}
+CANN_BKGS=${CANN_BKGS:-/opt/huawei/dataset/zyr_yuyin/lyf/vllm_bkgs_1015}
+
+MODEL_PATH=${MODEL_PATH:-/opt/huawei/dataset/zyr_yuyin/models/Qwen/Qwen3___5-27B}
+BASE_TASKS=${BASE_TASKS:-${SCRIPT_DIR}/数据示例}
+RESULT_ROOT=${RESULT_ROOT:-${SCRIPT_DIR}/result_nanoclaw_vllm}
+RUNNER_MODULE=${RUNNER_MODULE:-vllm_nanoclaw_runtime.cli}
+
+GCC_INSTALL_PREFIX=${GCC_INSTALL_PREFIX:-/home/ma-user/gcc-11.3.0}
+COMPILED_GCC_ARCHIVE_PATH=${COMPILED_GCC_ARCHIVE_PATH:-/opt/huawei/dataset/zyr_yuyin/bkgs/gcc-11.3.0-compiled-aarch64.tar.gz}
+
+# 第一次跑或环境不确定时保持默认 1；如果环境已经装好，可 SETUP_ENV=0 跳过安装段。
+SETUP_ENV=${SETUP_ENV:-1}
+
+chmod 755 "${INSTALL_DIR}" || true
+mkdir -p "${RESULT_ROOT}"
+
+# ================= NPU 基础信息 =================
+npu-smi info || true
+
+if [ "${SETUP_ENV}" = "1" ]; then
+    # ================= Python / 基础包 =================
+    pip install --upgrade pip
+    pip uninstall -y moxing-framework || true
+
+    # ================= GCC 11.3.0 =================
+    echo "--> 正在从缓存恢复 GCC 11.3.0..."
+    tar -xzf "${COMPILED_GCC_ARCHIVE_PATH}" -C /home/ma-user/
+    export PATH=${GCC_INSTALL_PREFIX}/bin:${PATH}
+    export LD_LIBRARY_PATH=${GCC_INSTALL_PREFIX}/lib64:${GCC_INSTALL_PREFIX}/lib:${LD_LIBRARY_PATH:-}
+    export CC=${GCC_INSTALL_PREFIX}/bin/gcc
+    export CXX=${GCC_INSTALL_PREFIX}/bin/g++
+    echo "--> 验证 GCC 版本:"
+    gcc --version
+
+    # ================= 准备安装包 =================
+    cd "${BKGS}"
+    cp jemalloc-5.3.0.tar.bz2 "${INSTALL_DIR}" || true
+
+    rm -rf "${INSTALL_DIR}/vllm" "${INSTALL_DIR}/vllm-ascend"
+    cp -r "${VLLM_LATEST_PKGS}/vllm" "${INSTALL_DIR}"
+    cp -r "${VLLM_LATEST_PKGS}/vllm-ascend" "${INSTALL_DIR}"
+
+    cp "${CANN_BKGS}/Ascend-cann-toolkit_8.5.0_linux-aarch64.run" "${INSTALL_DIR}"
+    cp "${CANN_BKGS}/Ascend-cann-910b-ops_8.5.0_linux-aarch64.run" "${INSTALL_DIR}"
+    cp "${CANN_BKGS}/Ascend-cann-nnal_8.5.0_linux-aarch64.run" "${INSTALL_DIR}"
+
+    # ================= 安装 CANN / NNAL =================
+    echo "################"
+    echo "## set ascend env"
+    echo "################"
+
+    cd "${INSTALL_DIR}"
+
+    chmod +x Ascend-cann-toolkit_8.5.0_linux-aarch64.run
+    bash Ascend-cann-toolkit_8.5.0_linux-aarch64.run --install --quiet
+    source "${INSTALL_DIR}/Ascend/ascend-toolkit/set_env.sh"
+
+    chmod +x Ascend-cann-910b-ops_8.5.0_linux-aarch64.run
+    bash Ascend-cann-910b-ops_8.5.0_linux-aarch64.run --install --quiet
+
+    chmod +x Ascend-cann-nnal_8.5.0_linux-aarch64.run
+    bash Ascend-cann-nnal_8.5.0_linux-aarch64.run --install --quiet
+    source "${INSTALL_DIR}/Ascend/nnal/atb/set_env.sh"
+
+    export ASCEND_HOME_PATH=${ASCEND_TOOLKIT_HOME}
+    export LD_LIBRARY_PATH=/usr/local/Ascend/driver/lib64:/usr/local/Ascend/driver/lib64/common:${LD_LIBRARY_PATH:-}
+    echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
+
+    # ================= 安装 PyTorch / torch-npu =================
+    pip3 install torch==2.9.0
+    pip3 install pyyaml setuptools
+    pip3 install torch-npu==2.9.0
+    pip3 install torchvision==0.24.0 torchaudio==2.9.0
+
+    ASCEND_TOOLKIT_PYTHON_PATH=/home/ma-user/Ascend/ascend-toolkit/latest/python/site-packages
+    export PYTHONPATH=${PYTHONPATH:-}:${INSTALL_DIR}:${ASCEND_TOOLKIT_PYTHON_PATH}
+    pip install pybind11==2.13.6
+
+    # ================= 安装 vLLM / vLLM-Ascend =================
+    cd "${INSTALL_DIR}/vllm"
+    VLLM_TARGET_DEVICE=empty pip install .
+
+    cd "${INSTALL_DIR}/vllm-ascend"
+    pip install -e .
+
+    # ================= 可选 jemalloc：默认关闭，避免额外编译耗时 =================
+    INSTALL_JEMALLOC=${INSTALL_JEMALLOC:-0}
+    if [ "${INSTALL_JEMALLOC}" = "1" ]; then
+        cd "${INSTALL_DIR}"
+        tar -xvf jemalloc-5.3.0.tar.bz2
+        cd jemalloc-5.3.0
+        ./configure --prefix="${INSTALL_DIR}"
+        make -j"$(nproc)"
+        make install
+        export LD_PRELOAD=${INSTALL_DIR}/lib/libjemalloc.so.2:${LD_PRELOAD:-}
+    fi
+
+    # ================= 安装 Triton-Ascend 3.2.1 =================
+    pip install --no-deps /opt/huawei/dataset/zyr_yuyin/bkgs/triton_ascend-3.2.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl
+
+    # ================= 安装 VERL 依赖：沿用之前环境，主要提供 transformers/tokenizer 等 =================
+    cd "${WORK_DIR}"
+    pip install -r requirements-npu.txt
+    pip install -e .
+    pip install --upgrade 'urllib3==1.26.11'
+    pip install loguru
+    pip install tree_sitter==0.21.3
+    pip install tree-sitter-java==0.21.0
+    pip install tree-sitter-javascript==0.21.4
+
+    ACL_PATH=/home/ma-user/Ascend/ascend-toolkit/latest/aarch64-linux/lib64
+    export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${ACL_PATH}
+    echo "LD_LIBRARY_PATH=${LD_LIBRARY_PATH}"
+
+    pip uninstall -y transformers || true
+    pip install transformers==5.3.0
+    pip install accelerate==1.13.0 mathruler
+    pip install jsonargparse
+    pip install deepdiff sympy html2text requests bs4 mpmath swanlab PandoraBox json_repair
+    pip list
+else
+    # 环境已经装好时，仍然尝试 source CANN/NNAL 环境。
+    if [ -f "${INSTALL_DIR}/Ascend/ascend-toolkit/set_env.sh" ]; then
+        source "${INSTALL_DIR}/Ascend/ascend-toolkit/set_env.sh"
+    fi
+    if [ -f "${INSTALL_DIR}/Ascend/nnal/atb/set_env.sh" ]; then
+        source "${INSTALL_DIR}/Ascend/nnal/atb/set_env.sh"
+    fi
+    export PATH=${GCC_INSTALL_PREFIX}/bin:${PATH}
+    export LD_LIBRARY_PATH=${GCC_INSTALL_PREFIX}/lib64:${GCC_INSTALL_PREFIX}/lib:${LD_LIBRARY_PATH:-}
+    export PYTHONPATH=${PYTHONPATH:-}:${INSTALL_DIR}:/home/ma-user/Ascend/ascend-toolkit/latest/python/site-packages
+    export ASCEND_HOME_PATH=${ASCEND_TOOLKIT_HOME:-/home/ma-user/Ascend/ascend-toolkit/latest}
+    export LD_LIBRARY_PATH=/usr/local/Ascend/driver/lib64:/usr/local/Ascend/driver/lib64/common:${LD_LIBRARY_PATH:-}
+    export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/home/ma-user/Ascend/ascend-toolkit/latest/aarch64-linux/lib64
+fi
+
+# ================= PLOG：兼容 ModelArts 环境；非 ModelArts 也能跑 =================
+if [ -n "${MA_VJ_NAME:-}" ] && [ -n "${VC_TASK_INDEX:-}" ] && [ -n "${MA_LOG_DIR:-}" ]; then
+    ma_vj_name=$(echo "${MA_VJ_NAME}" | sed 's:ma-job:modelarts-job:g')
+    task_name=worker-${VC_TASK_INDEX}
+    task_plog_path=${MA_LOG_DIR}/${ma_vj_name}/${task_name}
+    mkdir -p "${task_plog_path}"
+    export ASCEND_PROCESS_LOG_PATH=${task_plog_path}/${VC_TASK_INDEX}
+else
+    export ASCEND_PROCESS_LOG_PATH=${ASCEND_PROCESS_LOG_PATH:-${SCRIPT_DIR}/plog_nanoclaw_vllm}
+    mkdir -p "${ASCEND_PROCESS_LOG_PATH}"
+fi
+echo "plog path: ${ASCEND_PROCESS_LOG_PATH}"
+
+# ================= 单机 vLLM/HCCL 环境：沿用可运行 eager 配置 =================
+cd "${PROJECT_ROOT}"
+export PYTHONPATH=${PROJECT_ROOT}:${PYTHONPATH:-}
+
+export ASCEND_RT_VISIBLE_DEVICES=${ASCEND_RT_VISIBLE_DEVICES:-0,1,2,3}
+export OMP_NUM_THREADS=${OMP_NUM_THREADS:-1}
+export TOKENIZERS_PARALLELISM=false
+export PYTHONUNBUFFERED=1
+export ASCEND_GLOBAL_LOG_LEVEL=${ASCEND_GLOBAL_LOG_LEVEL:-3}
+
+export VLLM_LOGGING_LEVEL=${VLLM_LOGGING_LEVEL:-INFO}
+export VLLM_USE_V1=${VLLM_USE_V1:-1}
+export VLLM_ENABLE_V1_MULTIPROCESSING=${VLLM_ENABLE_V1_MULTIPROCESSING:-0}
+export VLLM_ASCEND_ENABLE_NZ=${VLLM_ASCEND_ENABLE_NZ:-0}
+export VLLM_ENGINE_ITERATION_TIMEOUT_S=${VLLM_ENGINE_ITERATION_TIMEOUT_S:-3600}
+export VLLM_WORKER_MULTIPROC_METHOD=${VLLM_WORKER_MULTIPROC_METHOD:-spawn}
+
+# eager 兜底：规避 profile_run / torch.compile / TorchDynamo 相关问题。
+export TORCHDYNAMO_DISABLE=${TORCHDYNAMO_DISABLE:-1}
+export TORCH_COMPILE_DISABLE=${TORCH_COMPILE_DISABLE:-1}
+
+export HCCL_CONNECT_TIMEOUT=${HCCL_CONNECT_TIMEOUT:-3600}
+export HCCL_EXEC_TIMEOUT=${HCCL_EXEC_TIMEOUT:-3600}
+export HCCL_EVENT_TIMEOUT=${HCCL_EVENT_TIMEOUT:-7200}
+export HCCL_BUFFSIZE=${HCCL_BUFFSIZE:-8}
+export P2P_HCCL_BUFFSIZE=${P2P_HCCL_BUFFSIZE:-16}
+export HCCL_OP_EXPANSION_MODE=${HCCL_OP_EXPANSION_MODE:-AIV}
+export HCCL_ASYNC_ERROR_HANDLING=${HCCL_ASYNC_ERROR_HANDLING:-0}
+
+export TASK_QUEUE_ENABLE=${TASK_QUEUE_ENABLE:-1}
+export COMBINED_ENABLE=${COMBINED_ENABLE:-1}
+export CLOSE_MATMUL_K_SHIFT=${CLOSE_MATMUL_K_SHIFT:-1}
+export ATB_MATMUL_SHUFFLE_K_ENABLE=${ATB_MATMUL_SHUFFLE_K_ENABLE:-0}
+export PYTORCH_NPU_ALLOC_CONF=${PYTORCH_NPU_ALLOC_CONF:-expandable_segments:True}
+
+ulimit -n 65536 || true
+npu-smi info || true
+
+# ================= vLLM / agent 参数 =================
+TP=${TP:-4}
+DTYPE=${DTYPE:-bfloat16}
+MAX_MODEL_LEN=${MAX_MODEL_LEN:-262144}
+MAX_NUM_BATCHED_TOKENS=${MAX_NUM_BATCHED_TOKENS:-32768}
+MAX_NUM_SEQS=${MAX_NUM_SEQS:-512}
+GPU_MEMORY_UTILIZATION=${GPU_MEMORY_UTILIZATION:-0.70}
+
+MAX_STEPS=${MAX_STEPS:-20}
+AGENT_BATCH_SIZE=${AGENT_BATCH_SIZE:-8}
+MAX_TOKENS=${MAX_TOKENS:-2048}
+TEMPERATURE=${TEMPERATURE:-0.2}
+TOP_P=${TOP_P:-0.95}
+TOP_K=${TOP_K:--1}
+DISABLE_THINKING=${DISABLE_THINKING:-1}
+RESUME=${RESUME:-0}
+OVERWRITE=${OVERWRITE:-1}
+ENFORCE_EAGER=${ENFORCE_EAGER:-1}
+ENABLE_PREFIX_CACHING=${ENABLE_PREFIX_CACHING:-0}
+RUN_VERIFIER=${RUN_VERIFIER:-0}
+ALLOW_PYTHON_TOOL=${ALLOW_PYTHON_TOOL:-0}
+PYTHON_TIMEOUT=${PYTHON_TIMEOUT:-20}
+BASH_TIMEOUT=${BASH_TIMEOUT:-20}
+VERIFIER_TIMEOUT=${VERIFIER_TIMEOUT:-120}
+
+# 可选：只跑某些任务。多个任务用逗号分隔，如 TASK_IDS=data_1487,data_0002。
+TASK_IDS=${TASK_IDS:-}
+TASK_GLOB=${TASK_GLOB:-data_*}
+
+if [ ! -f "${RUNTIME_DIR}/cli.py" ]; then
+    echo "ERROR: vllm_nanoclaw_runtime cli.py not found: ${RUNTIME_DIR}/cli.py" >&2
+    exit 2
+fi
+
+if [ ! -d "${BASE_TASKS}" ]; then
+    echo "ERROR: BASE_TASKS directory not found: ${BASE_TASKS}" >&2
+    exit 2
+fi
+
+mkdir -p "${RESULT_ROOT}"
+
+args=(
+    --base-tasks "${BASE_TASKS}"
+    --output "${RESULT_ROOT}"
+    --model "${MODEL_PATH}"
+    --task-glob "${TASK_GLOB}"
+    --tensor-parallel-size "${TP}"
+    --dtype "${DTYPE}"
+    --max-model-len "${MAX_MODEL_LEN}"
+    --max-num-batched-tokens "${MAX_NUM_BATCHED_TOKENS}"
+    --max-num-seqs "${MAX_NUM_SEQS}"
+    --gpu-memory-utilization "${GPU_MEMORY_UTILIZATION}"
+    --max-steps "${MAX_STEPS}"
+    --agent-batch-size "${AGENT_BATCH_SIZE}"
+    --max-tokens "${MAX_TOKENS}"
+    --temperature "${TEMPERATURE}"
+    --top-p "${TOP_P}"
+    --top-k "${TOP_K}"
+    --python-timeout "${PYTHON_TIMEOUT}"
+    --bash-timeout "${BASH_TIMEOUT}"
+    --verifier-timeout "${VERIFIER_TIMEOUT}"
+)
+
+if [ -n "${TASK_IDS}" ]; then
+    IFS=',' read -ra task_id_array <<< "${TASK_IDS}"
+    for task_id in "${task_id_array[@]}"; do
+        task_id_trimmed=$(echo "${task_id}" | xargs)
+        if [ -n "${task_id_trimmed}" ]; then
+            args+=(--task-id "${task_id_trimmed}")
+        fi
+    done
+fi
+
+if [ "${DISABLE_THINKING}" = "1" ] || [ "${DISABLE_THINKING}" = "true" ] || [ "${DISABLE_THINKING}" = "True" ]; then
+    args+=(--disable-thinking)
+else
+    args+=(--enable-thinking)
+fi
+
+if [ "${RESUME}" = "1" ] || [ "${RESUME}" = "true" ] || [ "${RESUME}" = "True" ]; then
+    args+=(--resume)
+elif [ "${OVERWRITE}" = "1" ] || [ "${OVERWRITE}" = "true" ] || [ "${OVERWRITE}" = "True" ]; then
+    args+=(--overwrite)
+fi
+
+if [ "${ENFORCE_EAGER}" = "1" ] || [ "${ENFORCE_EAGER}" = "true" ] || [ "${ENFORCE_EAGER}" = "True" ]; then
+    args+=(--enforce-eager)
+fi
+
+if [ "${ENABLE_PREFIX_CACHING}" = "1" ] || [ "${ENABLE_PREFIX_CACHING}" = "true" ] || [ "${ENABLE_PREFIX_CACHING}" = "True" ]; then
+    args+=(--enable-prefix-caching)
+fi
+
+if [ "${RUN_VERIFIER}" = "1" ] || [ "${RUN_VERIFIER}" = "true" ] || [ "${RUN_VERIFIER}" = "True" ]; then
+    args+=(--run-verifier)
+fi
+
+if [ "${ALLOW_PYTHON_TOOL}" = "1" ] || [ "${ALLOW_PYTHON_TOOL}" = "true" ] || [ "${ALLOW_PYTHON_TOOL}" = "True" ]; then
+    args+=(--allow-python-tool)
+fi
+
+cat <<INFO
+========== vLLM Nanoclaw-like eager runner config ==========
+SCRIPT_VERSION=${SCRIPT_VERSION}
+SCRIPT_DIR=${SCRIPT_DIR}
+RUNTIME_DIR=${RUNTIME_DIR}
+PROJECT_ROOT=${PROJECT_ROOT}
+RUNNER_MODULE=${RUNNER_MODULE}
+BASE_TASKS=${BASE_TASKS}
+RESULT_ROOT=${RESULT_ROOT}
+MODEL_PATH=${MODEL_PATH}
+ASCEND_RT_VISIBLE_DEVICES=${ASCEND_RT_VISIBLE_DEVICES}
+TP=${TP}
+DTYPE=${DTYPE}
+MAX_MODEL_LEN=${MAX_MODEL_LEN}
+MAX_NUM_BATCHED_TOKENS=${MAX_NUM_BATCHED_TOKENS}
+MAX_NUM_SEQS=${MAX_NUM_SEQS}
+GPU_MEMORY_UTILIZATION=${GPU_MEMORY_UTILIZATION}
+MAX_STEPS=${MAX_STEPS}
+AGENT_BATCH_SIZE=${AGENT_BATCH_SIZE}
+MAX_TOKENS=${MAX_TOKENS}
+TEMPERATURE=${TEMPERATURE}
+TOP_P=${TOP_P}
+TOP_K=${TOP_K}
+DISABLE_THINKING=${DISABLE_THINKING}
+ENFORCE_EAGER=${ENFORCE_EAGER}
+ENABLE_PREFIX_CACHING=${ENABLE_PREFIX_CACHING}
+RUN_VERIFIER=${RUN_VERIFIER}
+ALLOW_PYTHON_TOOL=${ALLOW_PYTHON_TOOL}
+BASH_TIMEOUT=${BASH_TIMEOUT}
+TASK_IDS=${TASK_IDS}
+TASK_GLOB=${TASK_GLOB}
+SETUP_ENV=${SETUP_ENV}
+VLLM_USE_V1=${VLLM_USE_V1}
+VLLM_ENABLE_V1_MULTIPROCESSING=${VLLM_ENABLE_V1_MULTIPROCESSING}
+VLLM_WORKER_MULTIPROC_METHOD=${VLLM_WORKER_MULTIPROC_METHOD}
+TORCHDYNAMO_DISABLE=${TORCHDYNAMO_DISABLE}
+TORCH_COMPILE_DISABLE=${TORCH_COMPILE_DISABLE}
+HCCL_BUFFSIZE=${HCCL_BUFFSIZE}
+P2P_HCCL_BUFFSIZE=${P2P_HCCL_BUFFSIZE}
+============================================================
+INFO
+
+python3 -m "${RUNNER_MODULE}" "${args[@]}"

v2/vllm_nanoclaw_runtime/runner.py

@@ -0,0 +1,456 @@
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+import subprocess
+import sys
+import time
+from collections.abc import Iterable
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .backend import generate_reply, generate_replies
+from .prompts import build_system_prompt
+from .protocol import parse_model_reply
+from .tools import execute_actions, workspace_subprocess_env
+from .types import TaskRunState, TaskSpec
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def run_task(
+    *,
+    spec: TaskSpec,
+    result_root: Path,
+    llm: Any,
+    tokenizer: Any,
+    sampling_params: Any,
+    args: argparse.Namespace,
+) -> dict[str, Any]:
+    prepared = prepare_task_run_state(spec=spec, result_root=result_root, args=args)
+    if isinstance(prepared, dict):
+        return prepared
+
+    state = prepared
+    try:
+        while state.status == "running" and state.steps_used < args.max_steps:
+            reply = generate_reply(
+                llm=llm,
+                tokenizer=tokenizer,
+                sampling_params=sampling_params,
+                messages=state.messages,
+                enable_thinking=args.enable_thinking,
+            )
+            process_task_reply(state, reply, args=args)
+    except Exception as exc:
+        state.status = "failed"
+        state.error = f"{type(exc).__name__}: {exc}"
+        state.events.append({"step": state.steps_used + 1, "error": state.error})
+        write_task_state_history(state)
+        raise
+
+    return finalize_task_state(state, args=args)
+
+
+def prepare_task_run_state(
+    *,
+    spec: TaskSpec,
+    result_root: Path,
+    args: argparse.Namespace,
+) -> TaskRunState | dict[str, Any]:
+    result_dir = result_root / spec.task_id
+    if result_dir.exists():
+        if args.overwrite:
+            shutil.rmtree(result_dir)
+        elif args.resume and is_completed_result(result_dir):
+            print(f"[skip] {spec.task_id}: completed result exists at {result_dir}", file=sys.stderr)
+            return {"task_id": spec.task_id, "status": "skipped", "result_dir": str(result_dir)}
+        else:
+            raise FileExistsError(f"result dir already exists: {result_dir}; pass --overwrite or --resume")
+
+    result_dir.mkdir(parents=True, exist_ok=False)
+    workspace_after = result_dir / "workspace_after"
+    workspace_before = result_dir / "workspace_before"
+    workspace_after.mkdir(parents=True, exist_ok=False)
+
+    prompt_text = spec.prompt_path.read_text(encoding="utf-8")
+    shutil.copy2(spec.prompt_path, result_dir / "task_prompt.md")
+    if spec.verifier_path is not None:
+        shutil.copy2(spec.verifier_path, result_dir / "verify_workplace.py")
+
+    env_result = run_env_builder(spec.env_builder_path, workspace_after)
+    shutil.copytree(workspace_after, workspace_before)
+
+    messages = build_initial_messages(
+        prompt_text=prompt_text,
+        workspace_after=workspace_after,
+        args=args,
+    )
+    state = TaskRunState(
+        spec=spec,
+        result_dir=result_dir,
+        workspace_before=workspace_before,
+        workspace_after=workspace_after,
+        history_path=result_dir / "conversation_history.json",
+        metadata_path=result_dir / "runner_metadata.json",
+        prompt_text=prompt_text,
+        env_result=env_result,
+        started_at=utc_now(),
+        messages=messages,
+    )
+    write_task_state_history(state)
+    return state
+
+
+def build_initial_messages(
+    *,
+    prompt_text: str,
+    workspace_after: Path,
+    args: argparse.Namespace,
+) -> list[dict[str, str]]:
+    return [
+        {
+            "role": "system",
+            "content": build_system_prompt(
+                args.allow_python_tool,
+                workspace_dir=workspace_after,
+                model=args.model,
+                max_steps=args.max_steps,
+            ),
+        },
+        {
+            "role": "user",
+            "content": (
+                "Solve this task by using Nanoclaw-compatible tool calls to inspect and modify the workspace.\n"
+                "On every assistant turn, first write a concise Thought section, then write either an Action section with JSON tool calls or a Final section.\n"
+                "Only provide a final answer after the requested workspace changes are complete.\n\n"
+                f"Task:\n{prompt_text}"
+            ),
+        },
+    ]
+
+
+def run_tasks_batched(
+    *,
+    specs: list[TaskSpec],
+    result_root: Path,
+    llm: Any,
+    tokenizer: Any,
+    sampling_params: Any,
+    args: argparse.Namespace,
+) -> list[dict[str, Any]]:
+    results: list[dict[str, Any]] = []
+    states: list[TaskRunState] = []
+
+    for spec in specs:
+        print(f"[prepare] {spec.task_id}", file=sys.stderr)
+        try:
+            prepared = prepare_task_run_state(spec=spec, result_root=result_root, args=args)
+        except Exception as exc:
+            result = {
+                "task_id": spec.task_id,
+                "status": "failed",
+                "result_dir": str(result_root / spec.task_id),
+                "error": f"{type(exc).__name__}: {exc}",
+            }
+            results.append(result)
+            print(f"[error] {spec.task_id}: {result['error']}", file=sys.stderr)
+            continue
+
+        if isinstance(prepared, dict):
+            results.append(prepared)
+        else:
+            states.append(prepared)
+
+    while True:
+        active_states = [state for state in states if state.status == "running"]
+        if not active_states:
+            break
+
+        current_batch = active_states[: args.agent_batch_size]
+        print(
+            "[batch] "
+            + ", ".join(f"{state.spec.task_id}:step{state.steps_used + 1}" for state in current_batch),
+            file=sys.stderr,
+        )
+
+        try:
+            replies = generate_replies(
+                llm=llm,
+                tokenizer=tokenizer,
+                sampling_params=sampling_params,
+                message_batches=[state.messages for state in current_batch],
+                enable_thinking=args.enable_thinking,
+            )
+            for state, reply in zip(current_batch, replies, strict=True):
+                process_task_reply(state, reply, args=args)
+        except Exception as exc:
+            error = f"{type(exc).__name__}: {exc}"
+            for state in current_batch:
+                state.status = "failed"
+                state.error = error
+                state.events.append({"step": state.steps_used + 1, "error": error})
+                write_task_state_history(state)
+
+    for state in states:
+        results.append(finalize_task_state(state, args=args))
+    return results
+
+
+def process_task_reply(state: TaskRunState, reply: str, *, args: argparse.Namespace) -> None:
+    state.steps_used += 1
+    step = state.steps_used
+    state.messages.append({"role": "assistant", "content": reply})
+
+    try:
+        parsed_reply = parse_model_reply(reply)
+    except ValueError as exc:
+        observation = (
+            f"Action parse error: {exc}. Output exactly one turn in this format: "
+            "Thought: concise analysis, then Action: JSON tool_calls/actions; "
+            "or Thought: concise analysis, then Final: final answer only when the task is complete."
+        )
+        state.events.append({"step": step, "reply": reply, "error": observation})
+        if step >= args.max_steps:
+            state.status = "failed"
+            state.error = f"exceeded max steps ({args.max_steps}) without valid Thought+Action or Thought+Final"
+        else:
+            state.messages.append({"role": "user", "content": observation_message(observation)})
+        write_task_state_history(state)
+        return
+
+    if parsed_reply.is_final:
+        state.status = "completed"
+        state.final_answer = parsed_reply.final_answer or ""
+        state.events.append(
+            {
+                "step": step,
+                "reply": reply,
+                "thought": parsed_reply.thought,
+                "is_final": True,
+                "final_response_mode": "thought_final" if parsed_reply.thought else "plain_text_without_tool_calls",
+            }
+        )
+        write_task_state_history(state)
+        return
+
+    actions = parsed_reply.actions or []
+    action_events, observation, is_final, final_answer = execute_actions(
+        actions,
+        state.workspace_after,
+        args=args,
+        step=step,
+    )
+    state.events.append(
+        {
+            "step": step,
+            "reply": reply,
+            "thought": parsed_reply.thought,
+            "actions": action_events,
+            "observation": observation,
+            "is_final": is_final,
+        }
+    )
+    if is_final:
+        state.status = "completed"
+        state.final_answer = final_answer or ""
+        write_task_state_history(state)
+        return
+
+    if step >= args.max_steps:
+        state.status = "failed"
+        state.error = f"exceeded max steps ({args.max_steps}) without final answer"
+    else:
+        state.messages.append({"role": "user", "content": observation_message(observation)})
+    write_task_state_history(state)
+
+
+def observation_message(observation: str) -> str:
+    return (
+        f"Observation:\n{observation}\n\n"
+        "Analyze the observation first. Then respond with either:\n"
+        "Thought:\n<concise analysis>\nAction:\n<JSON tool call(s)>\n\n"
+        "or, if the task is complete:\n"
+        "Thought:\n<concise completion check>\nFinal:\n<final answer>"
+    )
+def finalize_task_state(state: TaskRunState, *, args: argparse.Namespace) -> dict[str, Any]:
+    if state.status == "running":
+        state.status = "failed"
+        state.error = state.error or f"exceeded max steps ({args.max_steps}) without final answer"
+
+    if args.run_verifier and state.spec.verifier_path is not None:
+        state.verifier_result = run_verifier(
+            state.result_dir / "verify_workplace.py",
+            state.workspace_after,
+            timeout=args.verifier_timeout,
+        )
+
+    write_task_state_history(state)
+    metadata = {
+        "task_id": state.spec.task_id,
+        "status": state.status,
+        "error": state.error,
+        "final_answer": state.final_answer,
+        "steps_used": state.steps_used,
+        "started_at": state.started_at,
+        "finished_at": utc_now(),
+        "result_dir": str(state.result_dir),
+        "prompt_path": str(state.spec.prompt_path),
+        "env_builder_path": str(state.spec.env_builder_path),
+        "verifier_source_path": str(state.spec.verifier_path) if state.spec.verifier_path else None,
+        "workspace_before": str(state.workspace_before),
+        "workspace_after": str(state.workspace_after),
+        "conversation_history": str(state.history_path),
+        "env_builder": state.env_result,
+        "verifier": state.verifier_result,
+        "model": args.model,
+        "tokenizer": args.tokenizer or args.model,
+        "max_steps": args.max_steps,
+        "agent_batch_size": args.agent_batch_size,
+        "allow_python_tool": args.allow_python_tool,
+        "bash_timeout": getattr(args, "bash_timeout", 20.0),
+        "tool_call_transport": "local_vllm_json_text",
+    }
+    state.metadata_path.write_text(json.dumps(metadata, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return {
+        "task_id": state.spec.task_id,
+        "status": state.status,
+        "result_dir": str(state.result_dir),
+        "error": state.error,
+    }
+
+
+def write_task_state_history(state: TaskRunState) -> None:
+    write_history(
+        state.history_path,
+        spec=state.spec,
+        status=state.status,
+        final_answer=state.final_answer,
+        error=state.error,
+        messages=state.messages,
+        events=state.events,
+        started_at=state.started_at,
+        steps_used=state.steps_used,
+    )
+
+
+def is_completed_result(result_dir: Path) -> bool:
+    metadata_path = result_dir / "runner_metadata.json"
+    if not metadata_path.is_file():
+        return False
+    try:
+        payload = json.loads(metadata_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return False
+    return payload.get("status") == "completed"
+
+
+def run_env_builder(env_builder_path: Path, workspace: Path) -> dict[str, Any]:
+    started = time.time()
+    process = subprocess.run(
+        [sys.executable, str(env_builder_path)],
+        cwd=workspace,
+        text=True,
+        capture_output=True,
+        env=workspace_subprocess_env(workspace),
+        check=False,
+    )
+    result = {
+        "returncode": process.returncode,
+        "stdout": process.stdout,
+        "stderr": process.stderr,
+        "elapsed_seconds": round(time.time() - started, 3),
+    }
+    if process.returncode != 0:
+        raise RuntimeError(
+            f"env_builder.py failed for {env_builder_path} with code {process.returncode}\n"
+            f"stdout:\n{process.stdout}\n\nstderr:\n{process.stderr}"
+        )
+    return result
+
+
+def run_verifier(verifier_path: Path, workspace: Path, *, timeout: float) -> dict[str, Any]:
+    started = time.time()
+    try:
+        process = subprocess.run(
+            [sys.executable, str(verifier_path), str(workspace)],
+            cwd=verifier_path.parent,
+            text=True,
+            capture_output=True,
+            env=workspace_subprocess_env(workspace),
+            timeout=timeout,
+            check=False,
+        )
+        result: dict[str, Any] = {
+            "returncode": process.returncode,
+            "stdout": process.stdout,
+            "stderr": process.stderr,
+            "elapsed_seconds": round(time.time() - started, 3),
+        }
+    except subprocess.TimeoutExpired as exc:
+        result = {
+            "returncode": None,
+            "stdout": exc.stdout or "",
+            "stderr": exc.stderr or "",
+            "elapsed_seconds": round(time.time() - started, 3),
+            "error": f"verifier timed out after {timeout:g}s",
+        }
+
+    score_path = workspace / "workplace_score.json"
+    if score_path.is_file():
+        try:
+            result["workplace_score"] = json.loads(score_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError as exc:
+            result["workplace_score_error"] = str(exc)
+    return result
+
+
+def write_history(
+    path: Path,
+    *,
+    spec: TaskSpec,
+    status: str,
+    final_answer: str | None,
+    error: str | None,
+    messages: list[dict[str, str]],
+    events: list[dict[str, Any]],
+    started_at: str,
+    steps_used: int,
+) -> None:
+    payload = {
+        "task_id": spec.task_id,
+        "status": status,
+        "final_answer": final_answer,
+        "error": error,
+        "started_at": started_at,
+        "updated_at": utc_now(),
+        "steps_used": steps_used,
+        "messages": messages,
+        "events": events,
+    }
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def write_summary(output_root: Path, results: list[dict[str, Any]], started_at: str) -> None:
+    summary = {
+        "started_at": started_at,
+        "finished_at": utc_now(),
+        "total": len(results),
+        "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"),
+        "results": results,
+    }
+    output_root.mkdir(parents=True, exist_ok=True)
+    (output_root / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def iter_jsonl_results(results: Iterable[dict[str, Any]]) -> str:
+    return "".join(json.dumps(result, ensure_ascii=False) + "\n" for result in results)

v2/vllm_nanoclaw_runtime/tasks.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .types import TaskSpec
+
+
+def discover_tasks(base_tasks: Path, *, task_glob: str, task_ids: set[str] | None) -> list[TaskSpec]:
+    tasks_root = base_tasks / "tasks"
+    if not tasks_root.is_dir():
+        raise FileNotFoundError(f"tasks directory not found: {tasks_root}")
+
+    script_root = find_script_root(base_tasks)
+    specs: list[TaskSpec] = []
+    for task_dir in sorted(path for path in tasks_root.glob(task_glob) if path.is_dir()):
+        task_id = task_dir.name
+        if task_ids is not None and task_id not in task_ids:
+            continue
+
+        env_builder_path = task_dir / "env_builder.py"
+        if not env_builder_path.is_file():
+            continue
+
+        prompt_path = find_prompt_path(tasks_root, task_dir, task_id)
+        verifier_path = find_verifier_path(script_root, task_id) if script_root is not None else None
+        specs.append(
+            TaskSpec(
+                task_id=task_id,
+                task_dir=task_dir,
+                prompt_path=prompt_path,
+                env_builder_path=env_builder_path,
+                verifier_path=verifier_path,
+            )
+        )
+
+    if task_ids is not None:
+        found_ids = {spec.task_id for spec in specs}
+        missing_ids = sorted(task_ids - found_ids)
+        if missing_ids:
+            raise FileNotFoundError(f"requested task ids not found or missing env_builder.py: {missing_ids}")
+    if not specs:
+        raise FileNotFoundError(f"no task directories matched {task_glob!r} under {tasks_root}")
+    return specs
+
+
+def find_script_root(base_tasks: Path) -> Path | None:
+    for dirname in ("scrips", "scripts"):
+        candidate = base_tasks / dirname
+        if candidate.is_dir():
+            return candidate
+    return None
+
+
+def find_prompt_path(tasks_root: Path, task_dir: Path, task_id: str) -> Path:
+    candidates = (
+        tasks_root / "prompts" / f"{task_id}.md",
+        task_dir / "prompt.md",
+        task_dir / "task.md",
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    raise FileNotFoundError(
+        f"prompt file not found for {task_id}; tried: "
+        + ", ".join(str(path) for path in candidates)
+    )
+
+
+def find_verifier_path(script_root: Path, task_id: str) -> Path | None:
+    candidates = (
+        script_root / task_id / "verify_workplace.py",
+        script_root / f"{task_id}.py",
+        script_root / "verify_workplace.py",
+    )
+    for candidate in candidates:
+        if candidate.is_file():
+            return candidate
+    return None

v2/vllm_nanoclaw_runtime/tools.py

@@ -0,0 +1,705 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any
+
+from .types import ToolResult
+
+
+DANGEROUS_PYTHON_PATTERNS = (
+    "rm -",
+    "rmtree",
+    "unlink",
+    "remove(",
+    "removedirs",
+    "rmdir",
+    "os.system",
+    "os.popen",
+    "subprocess",
+    "shutil",
+    "send2trash",
+    "__import__",
+    "eval(",
+    "exec(",
+    "compile(",
+    "socket",
+    "httpx",
+    "requests",
+    "urllib",
+)
+ABSOLUTE_PATH_LITERAL = re.compile(r"[\"']/(?:[^\"']*)[\"']")
+MAX_BASH_OUTPUT_CHARS = 4000
+BASH_CONTROL_SPLIT = re.compile(r"\s*(?:&&|\|\||;|\n)\s*")
+BASH_UNSUPPORTED_TOKENS = (">", "<", "`", "$(", "${", "$[", "<(", ">(")
+BASH_COMMANDS_WITH_PATH_OPERANDS = {
+    "cat",
+    "head",
+    "tail",
+    "wc",
+    "ls",
+    "mkdir",
+    "touch",
+    "rm",
+    "cp",
+    "mv",
+    "chmod",
+}
+BASH_ALLOWED_COMMANDS = BASH_COMMANDS_WITH_PATH_OPERANDS | {
+    "pwd",
+    "echo",
+    "printf",
+    "true",
+    "false",
+    "test",
+    "[",
+    "set",
+    "grep",
+    "find",
+    "sort",
+    "uniq",
+    "cut",
+    "bash",
+    "sh",
+}
+
+
+def execute_actions(
+    actions: list[dict[str, Any]],
+    workspace: Path,
+    *,
+    args: Any,
+    step: int,
+) -> tuple[list[dict[str, Any]], str, bool, str | None]:
+    action_events: list[dict[str, Any]] = []
+    observations: list[str] = []
+    final_answer: str | None = None
+    is_final = False
+
+    for index, action in enumerate(actions, start=1):
+        result = execute_action(action, workspace, args=args, step=step)
+        action_name = str(action.get("action") or action.get("tool") or "<missing>")
+        action_events.append(
+            {
+                "index": index,
+                "action": action,
+                "observation": result.observation,
+                "is_final": result.is_final,
+            }
+        )
+        observations.append(f"Tool result {index} ({action_name}):\n{result.observation}")
+        if result.is_final:
+            is_final = True
+            final_answer = result.final_answer
+            break
+
+    return action_events, "\n\n".join(observations), is_final, final_answer
+
+
+def execute_action(action: dict[str, Any], workspace: Path, *, args: Any, step: int) -> ToolResult:
+    action_name = str(action.get("action", "")).strip()
+    try:
+        if action_name in {"list_dir", "ls"}:
+            path = str(action.get("path") or ".")
+            if bool(action.get("recursive", False)):
+                return ToolResult(list_dir_recursive(workspace, path, limit=args.list_limit))
+            return ToolResult(list_dir(workspace, path, limit=args.list_limit))
+        if action_name in {"read_file", "read"}:
+            return ToolResult(read_file(workspace, require_path_like(action), limit=args.read_limit))
+        if action_name in {"write_file", "write"}:
+            return ToolResult(write_file(workspace, require_path_like(action), require_string(action, "content")))
+        if action_name in {"edit_file", "edit"}:
+            return ToolResult(
+                edit_file(
+                    workspace,
+                    require_path_like(action),
+                    require_string(action, "old_text"),
+                    require_string(action, "new_text"),
+                    replace_all=bool(action.get("replace_all", False)),
+                )
+            )
+        if action_name == "apply_patch":
+            changes = action.get("changes")
+            if not isinstance(changes, list):
+                return ToolResult("Error: 'changes' must be a list.")
+            return ToolResult(apply_workspace_patch(workspace, changes))
+        if action_name == "grep":
+            return ToolResult(
+                grep_workspace(
+                    workspace,
+                    require_string(action, "pattern"),
+                    action.get("glob"),
+                    limit=args.list_limit,
+                )
+            )
+        if action_name == "find":
+            return ToolResult(find_workspace_files(workspace, action.get("pattern"), limit=args.list_limit))
+        if action_name in {"memory_search", "memory_get", "memory_append"}:
+            return ToolResult("Error: memory is disabled in this local no-memory runner.")
+        if action_name in {"exec", "execute_dangerous_command", "bash"}:
+            return ToolResult(
+                execute_bash(
+                    workspace,
+                    command=str(action.get("command", "")) if action.get("command") is not None else None,
+                    script=str(action.get("script", "")) if action.get("script") is not None else None,
+                    script_path=str(action.get("script_path", action.get("path", ""))) if (action.get("script_path") is not None or action.get("path") is not None) else None,
+                    step=step,
+                    timeout=float(getattr(args, "bash_timeout", 20.0)),
+                )
+            )
+        if action_name == "ask_human_for_confirmation":
+            command = str(action.get("command", ""))
+            return ToolResult(f"Human response: Reject (auto). Command not approved: {command}")
+        if action_name == "mkdir":
+            return ToolResult(make_dir(workspace, require_string(action, "path")))
+        if action_name == "run_python":
+            if not args.allow_python_tool:
+                return ToolResult("Error: run_python is disabled. Use read/write/edit/apply_patch actions instead.")
+            return ToolResult(run_python(workspace, require_string(action, "code"), step=step, timeout=args.python_timeout))
+        if action_name == "finish":
+            return ToolResult(
+                observation="Finished.",
+                is_final=True,
+                final_answer=str(action.get("answer") or ""),
+            )
+        if not action_name:
+            return ToolResult("Error: missing action field.")
+        return ToolResult(f"Error: Unknown tool '{action_name}'.")
+    except Exception as exc:
+        return ToolResult(f"Error while executing {action_name or '<missing>'}: {type(exc).__name__}: {exc}")
+
+
+def require_string(action: dict[str, Any], key: str) -> str:
+    value = action.get(key)
+    if not isinstance(value, str):
+        raise ValueError(f"field {key!r} must be a string")
+    return value
+
+
+def require_path_like(action: dict[str, Any]) -> str:
+    value = action.get("path", action.get("filename"))
+    if not isinstance(value, str):
+        raise ValueError("field 'path' must be a string")
+    return value
+
+
+def resolve_workspace_path(workspace: Path, relative_path: str) -> Path:
+    raw_path = relative_path.strip() or "."
+    candidate_path = Path(raw_path)
+    if candidate_path.is_absolute():
+        raise ValueError(f"absolute paths are not allowed: {relative_path}")
+    if any(part == ".." for part in candidate_path.parts):
+        raise ValueError(f"parent path '..' is not allowed: {relative_path}")
+    resolved = (workspace / candidate_path).resolve()
+    workspace_resolved = workspace.resolve()
+    if resolved != workspace_resolved and workspace_resolved not in resolved.parents:
+        raise ValueError(f"path escapes workspace: {relative_path}")
+    return resolved
+
+
+def relative_workspace_path(workspace: Path, path: Path) -> str:
+    workspace_resolved = workspace.resolve()
+    path_resolved = path.resolve()
+    if path_resolved == workspace_resolved:
+        return "."
+    return path_resolved.relative_to(workspace_resolved).as_posix()
+
+
+def json_dumps(payload: Any) -> str:
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
+def list_dir(workspace: Path, relative_path: str, *, limit: int) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    if not path.exists():
+        return "Error: path not found."
+    if path.is_file():
+        return json_dumps(
+            {
+                "path": relative_workspace_path(workspace, path),
+                "entries": [
+                    {
+                        "path": relative_workspace_path(workspace, path),
+                        "type": "file",
+                    }
+                ],
+                "truncated": False,
+            }
+        )
+
+    entries = []
+    truncated = False
+    for index, child in enumerate(sorted(path.iterdir())):
+        if index >= limit:
+            truncated = True
+            break
+        entries.append(
+            {
+                "path": relative_workspace_path(workspace, child),
+                "type": "dir" if child.is_dir() else "file",
+            }
+        )
+    return json_dumps(
+        {
+            "path": relative_workspace_path(workspace, path),
+            "entries": entries,
+            "truncated": truncated,
+        }
+    )
+
+
+def list_dir_recursive(workspace: Path, relative_path: str, *, limit: int) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    if not path.exists():
+        return "Error: path not found."
+    if path.is_file():
+        return list_dir(workspace, relative_path, limit=limit)
+
+    entries = []
+    truncated = False
+    for index, child in enumerate(sorted(path.rglob("*"))):
+        if index >= limit:
+            truncated = True
+            break
+        entries.append(
+            {
+                "path": relative_workspace_path(workspace, child),
+                "type": "dir" if child.is_dir() else "file",
+            }
+        )
+    return json_dumps(
+        {
+            "path": relative_workspace_path(workspace, path),
+            "entries": entries,
+            "truncated": truncated,
+        }
+    )
+
+
+def read_file(workspace: Path, relative_path: str, *, limit: int) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    if not path.exists():
+        return f"Error: file does not exist: {relative_path}"
+    if not path.is_file():
+        return f"Error: path is not a file: {relative_path}"
+    content = path.read_text(encoding="utf-8", errors="replace")
+    if len(content) > limit:
+        return content[:limit] + f"\n... truncated after {limit} characters"
+    return content
+
+
+def write_file(workspace: Path, relative_path: str, content: str) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return "Success: File written."
+
+
+def edit_file(
+    workspace: Path,
+    relative_path: str,
+    old_text: str,
+    new_text: str,
+    *,
+    replace_all: bool,
+) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    content = path.read_text(encoding="utf-8")
+    occurrences = content.count(old_text)
+    if occurrences == 0:
+        return "Error: target text not found."
+    if not replace_all and occurrences != 1:
+        return "Error: target text matched multiple locations. Pass replace_all=true or provide more specific old_text."
+    updated = content.replace(old_text, new_text) if replace_all else content.replace(old_text, new_text, 1)
+    path.write_text(updated, encoding="utf-8")
+    changed = occurrences if replace_all else 1
+    return f"Success: Applied {changed} edit(s)."
+
+
+def make_dir(workspace: Path, relative_path: str) -> str:
+    path = resolve_workspace_path(workspace, relative_path)
+    path.mkdir(parents=True, exist_ok=True)
+    return f"Success: directory exists: {relative_path}."
+
+
+def apply_workspace_patch(workspace: Path, changes: list[Any]) -> str:
+    if not changes:
+        return "Error: no changes provided."
+    results: list[str] = []
+    for index, change in enumerate(changes, start=1):
+        if not isinstance(change, dict):
+            return f"Error: change #{index} must be an object."
+        try:
+            result = edit_file(
+                workspace,
+                require_path_like(change),
+                require_string(change, "old_text"),
+                require_string(change, "new_text"),
+                replace_all=bool(change.get("replace_all", False)),
+            )
+        except Exception as exc:
+            return f"Error: {type(exc).__name__}: {exc} (change #{index})"
+        if result.startswith("Error:"):
+            return f"{result} (change #{index})"
+        results.append(f"change #{index}: {result}")
+    return "Success: Patch applied.\n" + "\n".join(results)
+
+
+def validate_glob_pattern(raw_pattern: str) -> str | None:
+    glob_path = Path(raw_pattern)
+    if glob_path.is_absolute() or any(part == ".." for part in glob_path.parts):
+        return "glob must stay inside the workspace"
+    return None
+
+
+def find_workspace_files(workspace: Path, pattern: Any, *, limit: int) -> str:
+    raw_pattern = str(pattern or "**/*").strip() or "**/*"
+    validation_error = validate_glob_pattern(raw_pattern)
+    if validation_error is not None:
+        return f"Error: {validation_error}."
+
+    files = []
+    truncated = False
+    for index, path in enumerate(sorted(path for path in workspace.glob(raw_pattern) if path.is_file())):
+        if index >= limit:
+            truncated = True
+            break
+        files.append(relative_workspace_path(workspace, path))
+    return json_dumps({"files": files, "truncated": truncated})
+
+
+def grep_workspace(workspace: Path, pattern: str, glob_pattern: Any, *, limit: int) -> str:
+    try:
+        regex = re.compile(pattern)
+    except re.error as exc:
+        return f"Error: invalid regex: {exc}"
+
+    raw_glob = str(glob_pattern or "**/*").strip() or "**/*"
+    validation_error = validate_glob_pattern(raw_glob)
+    if validation_error is not None:
+        return f"Error: {validation_error}."
+
+    matches: list[dict[str, Any]] = []
+    truncated = False
+    for path in sorted(path for path in workspace.glob(raw_glob) if path.is_file()):
+        try:
+            text = path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+        relative = relative_workspace_path(workspace, path)
+        for line_number, line in enumerate(text.splitlines(), start=1):
+            if not regex.search(line):
+                continue
+            if len(matches) >= limit:
+                truncated = True
+                return json_dumps({"matches": matches, "truncated": truncated})
+            matches.append({"path": relative, "line": line_number, "text": line})
+    return json_dumps({"matches": matches, "truncated": truncated})
+
+
+def execute_bash(
+    workspace: Path,
+    *,
+    command: str | None,
+    script: str | None,
+    script_path: str | None,
+    step: int,
+    timeout: float,
+) -> str:
+    provided = [value is not None and value.strip() != "" for value in (command, script, script_path)]
+    if sum(provided) != 1:
+        return "Error: provide exactly one of command, script, or script_path/path for bash execution."
+
+    temp_script_path: Path | None = None
+    try:
+        if script is not None and script.strip():
+            validation_error = validate_bash_text(workspace, script)
+            if validation_error is not None:
+                return validation_error
+            temp_script_path = workspace / f".vllm_nanoclaw_bash_step_{step}.sh"
+            temp_script_path.write_text(script, encoding="utf-8")
+            argv = ["bash", str(temp_script_path.name)]
+        elif script_path is not None and script_path.strip():
+            resolved_script_path = resolve_workspace_path(workspace, script_path)
+            if not resolved_script_path.is_file():
+                return f"Error: bash script does not exist: {script_path}"
+            script_content = resolved_script_path.read_text(encoding="utf-8", errors="replace")
+            validation_error = validate_bash_text(workspace, script_content)
+            if validation_error is not None:
+                return validation_error
+            argv = ["bash", script_path]
+        else:
+            raw_command = command or ""
+            validation_error = validate_bash_text(workspace, raw_command)
+            if validation_error is not None:
+                return validation_error
+            argv = ["bash", "-lc", raw_command]
+
+        try:
+            process = subprocess.run(
+                argv,
+                cwd=workspace,
+                text=True,
+                capture_output=True,
+                env=workspace_subprocess_env(workspace),
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            stdout = exc.stdout or ""
+            stderr = exc.stderr or ""
+            output = format_process_output(stdout, stderr)
+            return f"Error: bash timed out after {timeout:g}s\n{output}"
+    finally:
+        if temp_script_path is not None:
+            try:
+                temp_script_path.unlink()
+            except FileNotFoundError:
+                pass
+
+    output = format_process_output(process.stdout, process.stderr)
+    if len(output) > MAX_BASH_OUTPUT_CHARS:
+        output = output[:MAX_BASH_OUTPUT_CHARS] + "\n...(truncated)"
+    if process.returncode != 0:
+        return f"Error: bash exited with code {process.returncode}\n{output}"
+    return output
+
+
+def format_process_output(stdout: str | bytes | None, stderr: str | bytes | None) -> str:
+    stdout_text = stdout.decode() if isinstance(stdout, bytes) else (stdout or "")
+    stderr_text = stderr.decode() if isinstance(stderr, bytes) else (stderr or "")
+    output_parts = []
+    if stdout_text.strip():
+        output_parts.append(stdout_text.strip())
+    if stderr_text.strip():
+        output_parts.append(f"[stderr]\n{stderr_text.strip()}")
+    return "\n\n".join(output_parts) if output_parts else "(no output)"
+
+
+def validate_bash_text(workspace: Path, text: str) -> str | None:
+    if not text.strip():
+        return "Error: empty bash command/script."
+    unsupported_error = validate_unsupported_bash_syntax(text)
+    if unsupported_error is not None:
+        return unsupported_error
+
+    for line_number, raw_line in enumerate(text.splitlines() or [text], start=1):
+        stripped_line = raw_line.strip()
+        if not stripped_line or stripped_line.startswith("#") or stripped_line.startswith("#!"):
+            continue
+        for raw_segment in BASH_CONTROL_SPLIT.split(stripped_line):
+            segment = raw_segment.strip()
+            if not segment:
+                continue
+            segment_error = validate_bash_segment(workspace, segment)
+            if segment_error is not None:
+                return f"Error: unsafe bash at line {line_number}: {segment_error}"
+    return None
+
+
+def validate_unsupported_bash_syntax(text: str) -> str | None:
+    normalized = text.replace("&&", "").replace("||", "")
+    if "&" in normalized:
+        return "Error: unsupported bash syntax '&'. Background jobs are not allowed."
+    pipe_normalized = text.replace("||", "")
+    if "|" in pipe_normalized:
+        return "Error: unsupported bash syntax '|'. Pipes are not allowed."
+    for token in BASH_UNSUPPORTED_TOKENS:
+        if token in text:
+            return f"Error: unsupported bash syntax {token!r}. Redirection, command substitution, and process substitution are not allowed."
+    if "$" in text:
+        return "Error: unsupported bash syntax '$'. Variable expansion is not allowed in model-generated bash."
+    return None
+
+
+def validate_bash_segment(workspace: Path, segment: str) -> str | None:
+    try:
+        argv = shlex.split(segment)
+    except ValueError as exc:
+        return f"invalid command syntax: {exc}"
+    if not argv:
+        return None
+
+    command_name = argv[0]
+    if command_name not in BASH_ALLOWED_COMMANDS:
+        return f"command {command_name!r} is not allowed. Allowed commands: {', '.join(sorted(BASH_ALLOWED_COMMANDS))}"
+    if command_name in {"bash", "sh"}:
+        return validate_nested_bash_script(workspace, argv)
+    if command_name == "set":
+        return validate_set_command(argv)
+
+    for operand in bash_path_operands(argv):
+        path_error = validate_workspace_operand(workspace, operand)
+        if path_error is not None:
+            return path_error
+    return None
+
+
+def validate_set_command(argv: list[str]) -> str | None:
+    for argument in argv[1:]:
+        if not argument.startswith("-") and not argument.startswith("+"):
+            return "set only supports shell option flags in this restricted runner"
+    return None
+
+
+def validate_nested_bash_script(workspace: Path, argv: list[str]) -> str | None:
+    operands = list(iter_operands(argv[1:]))
+    if not operands:
+        return "bash/sh requires a script path in this restricted runner"
+    if operands[0] in {"-c", "--command"} or any(argument in {"-c", "--command"} for argument in argv[1:]):
+        return "bash/sh -c is not allowed inside restricted bash; use the bash tool command field instead"
+    script_operand = operands[0]
+    path_error = validate_workspace_operand(workspace, script_operand)
+    if path_error is not None:
+        return path_error
+    script_path = resolve_workspace_path(workspace, script_operand)
+    if not script_path.is_file():
+        return f"bash script does not exist: {script_operand}"
+    return validate_bash_text(workspace, script_path.read_text(encoding="utf-8", errors="replace"))
+
+
+def bash_path_operands(argv: list[str]) -> list[str]:
+    command_name = argv[0]
+    args = argv[1:]
+    if command_name == "pwd" or command_name in {"echo", "printf", "true", "false", "test", "["}:
+        return []
+    if command_name == "grep":
+        operands = list(iter_operands(args, options_with_values={"-e", "--regexp", "-f", "--file", "-m", "--max-count", "-A", "-B", "-C", "--after-context", "--before-context", "--context", "--include", "--exclude", "--exclude-dir"}))
+        uses_explicit_pattern_option = any(argument in {"-e", "--regexp", "-f", "--file"} or argument.startswith("-e") for argument in args)
+        return operands if uses_explicit_pattern_option else operands[1:]
+    if command_name == "find":
+        operands: list[str] = []
+        iterator = iter(args)
+        for argument in iterator:
+            if argument == "--":
+                continue
+            if argument.startswith("-") or argument in {"!", "(", ")"}:
+                if argument in {"-name", "-path", "-type", "-maxdepth", "-mindepth", "-size", "-mtime", "-newer"}:
+                    next(iterator, None)
+                continue
+            operands.append(argument)
+        return operands[:1]
+    if command_name == "cut":
+        return list(iter_operands(args, options_with_values={"-b", "-c", "-d", "-f", "--bytes", "--characters", "--delimiter", "--fields"}))
+    if command_name in {"head", "tail"}:
+        return list(iter_operands(args, options_with_values={"-n", "--lines", "-c", "--bytes"}))
+    if command_name == "chmod":
+        operands = list(iter_operands(args))
+        return operands[1:]
+    return list(iter_operands(args))
+
+
+def iter_operands(args: list[str], *, options_with_values: set[str] | None = None) -> list[str]:
+    options_with_values = options_with_values or set()
+    operands: list[str] = []
+    skip_next = False
+    after_double_dash = False
+    for argument in args:
+        if skip_next:
+            skip_next = False
+            continue
+        if not after_double_dash and argument == "--":
+            after_double_dash = True
+            continue
+        if not after_double_dash and argument.startswith("-") and argument != "-":
+            option_name = argument.split("=", 1)[0]
+            if option_name in options_with_values and "=" not in argument:
+                skip_next = True
+            continue
+        operands.append(argument)
+    return operands
+
+
+def validate_workspace_operand(workspace: Path, operand: str) -> str | None:
+    if operand in {"", "-"}:
+        return None
+    if operand.startswith("~"):
+        return f"path {operand!r} is not allowed: '~' expansion is disabled"
+
+    candidate_path = Path(operand)
+    workspace_resolved = workspace.resolve()
+    resolved = candidate_path.resolve() if candidate_path.is_absolute() else (workspace / candidate_path).resolve()
+    if resolved != workspace_resolved and workspace_resolved not in resolved.parents:
+        return f"path escapes workspace: {operand}"
+    return None
+
+
+def run_python(workspace: Path, code: str, *, step: int, timeout: float) -> str:
+    safety_error = validate_python_tool_code(code)
+    if safety_error is not None:
+        return f"Error: blocked unsafe Python code: {safety_error}"
+
+    script_path = workspace / f".vllm_nanoclaw_step_{step}.py"
+    script_path.write_text(code, encoding="utf-8")
+    try:
+        try:
+            process = subprocess.run(
+                [sys.executable, str(script_path.name)],
+                cwd=workspace,
+                text=True,
+                capture_output=True,
+                env=workspace_subprocess_env(workspace),
+                timeout=timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            stdout = exc.stdout or ""
+            stderr = exc.stderr or ""
+            output_parts = []
+            if stdout:
+                output_parts.append(str(stdout).strip())
+            if stderr:
+                output_parts.append(f"[stderr]\n{str(stderr).strip()}")
+            output = "\n\n".join(output_parts) if output_parts else "(no output)"
+            return f"Error: Python timed out after {timeout:g}s\n{output}"
+    finally:
+        try:
+            script_path.unlink()
+        except FileNotFoundError:
+            pass
+
+    output_parts = []
+    if process.stdout.strip():
+        output_parts.append(process.stdout.strip())
+    if process.stderr.strip():
+        output_parts.append(f"[stderr]\n{process.stderr.strip()}")
+    output = "\n\n".join(output_parts) if output_parts else "(no output)"
+    if process.returncode != 0:
+        return f"Error: Python exited with code {process.returncode}\n{output}"
+    return output
+
+
+def validate_python_tool_code(code: str) -> str | None:
+    lowered = code.lower()
+    if ".." in code:
+        return "parent-directory path '..' is not allowed"
+    absolute_match = ABSOLUTE_PATH_LITERAL.search(code)
+    if absolute_match:
+        return f"absolute path literal is not allowed: {absolute_match.group(0)}"
+    for pattern in DANGEROUS_PYTHON_PATTERNS:
+        if pattern in lowered:
+            return f"forbidden pattern {pattern!r}"
+    return None
+
+
+def workspace_subprocess_env(workspace: Path) -> dict[str, str]:
+    workspace_resolved = workspace.resolve()
+    home_dir = workspace_resolved / ".runner_home"
+    tmp_dir = workspace_resolved / ".runner_tmp"
+    home_dir.mkdir(parents=True, exist_ok=True)
+    tmp_dir.mkdir(parents=True, exist_ok=True)
+
+    env = dict(os.environ)
+    env["HOME"] = str(home_dir)
+    env["TMPDIR"] = str(tmp_dir)
+    env["TEMP"] = str(tmp_dir)
+    env["TMP"] = str(tmp_dir)
+    env["PWD"] = str(workspace_resolved)
+    env["PYTHONNOUSERSITE"] = "1"
+    env["NANOCLAW_WORKSPACE"] = str(workspace_resolved)
+    return env

v2/vllm_nanoclaw_runtime/types.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass(frozen=True, slots=True)
+class TaskSpec:
+    task_id: str
+    task_dir: Path
+    prompt_path: Path
+    env_builder_path: Path
+    verifier_path: Path | None
+
+
+@dataclass(frozen=True, slots=True)
+class ToolResult:
+    observation: str
+    is_final: bool = False
+    final_answer: str | None = None
+
+
+@dataclass(slots=True)
+class TaskRunState:
+    spec: TaskSpec
+    result_dir: Path
+    workspace_before: Path
+    workspace_after: Path
+    history_path: Path
+    metadata_path: Path
+    prompt_text: str
+    env_result: dict[str, Any]
+    started_at: str
+    messages: list[dict[str, str]] = field(default_factory=list)
+    events: list[dict[str, Any]] = field(default_factory=list)
+    status: str = "running"
+    error: str | None = None
+    final_answer: str | None = None
+    steps_used: int = 0
+    verifier_result: dict[str, Any] | None = None