roller-agent 0.2.0__py3-none-any.whl

roller/__init__.py

@@ -0,0 +1,31 @@
+"""Roller: batch collection of agentic trajectories."""
+
+from roller.version import __version__
+from roller.bundles import BundlePolicy, TaskBundleStore
+from roller.collector import CollectionConfig, Collector
+from roller.conversation import ConversationManager
+from roller.models import (
+    ContextFile,
+    HarnessResult,
+    InputFile,
+    RunRequest,
+    Task,
+    TaskBundle,
+    UserSimulatorSpec,
+)
+
+
+__all__ = [
+    "BundlePolicy",
+    "CollectionConfig",
+    "ContextFile",
+    "Collector",
+    "ConversationManager",
+    "HarnessResult",
+    "InputFile",
+    "RunRequest",
+    "Task",
+    "TaskBundle",
+    "TaskBundleStore",
+    "UserSimulatorSpec",
+]

roller/__main__.py

@@ -0,0 +1,6 @@
+from roller.cli import main
+
+
+if __name__ == "__main__":
+    main()
+

roller/actf.py

@@ -0,0 +1,431 @@
+from __future__ import annotations
+
+import json
+from copy import deepcopy
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable
+
+from roller.openclaw_delivery import OpenClawDeliveryTracker
+from roller.openclaw_usage import OpenClawUsage
+
+OPENCLAW_ANNOUNCEMENT_SFT_REASON = (
+    "OpenClaw announcement input lacks native response binding; use captured per-call contexts"
+)
+
+
+def _event_time(value: Any) -> datetime | None:
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        try:
+            return datetime.fromtimestamp(float(value) / 1000, tz=timezone.utc)
+        except (OverflowError, OSError, ValueError):
+            return None
+    if not isinstance(value, str) or not value.strip():
+        return None
+    text = value.strip()
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def _timestamp(value: Any) -> str | None:
+    parsed = _event_time(value)
+    return parsed.strftime("%Y-%m-%d %H:%M:%S.%f") if parsed is not None else None
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        parts: list[str] = []
+        for item in value:
+            if isinstance(item, str):
+                parts.append(item)
+            elif isinstance(item, dict) and isinstance(item.get("text"), str):
+                parts.append(item["text"])
+        return "\n".join(part for part in parts if part)
+    if isinstance(value, dict) and isinstance(value.get("text"), str):
+        return value["text"]
+    return "" if value is None else str(value)
+
+
+def _tool_call(block: dict[str, Any]) -> dict[str, Any]:
+    arguments = block.get("arguments", {})
+    if not isinstance(arguments, dict):
+        arguments = {"value": arguments}
+    return {
+        "type": "toolCall",
+        "id": str(block.get("id", "")),
+        "name": str(block.get("name", "")),
+        "arguments": deepcopy(arguments),
+    }
+
+
+def _assistant_parts(content: Any) -> tuple[str, str, list[dict[str, Any]]]:
+    if isinstance(content, str):
+        return content, "", []
+    if not isinstance(content, list):
+        return "", "", []
+    visible: list[str] = []
+    reasoning: list[str] = []
+    calls: list[dict[str, Any]] = []
+    for block in content:
+        if isinstance(block, str):
+            visible.append(block)
+            continue
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
+        if block_type == "text" and isinstance(block.get("text"), str):
+            visible.append(block["text"])
+        elif block_type in {"thinking", "reasoning"}:
+            value = block.get("thinking", block.get("text", block.get("reasoning", "")))
+            if isinstance(value, str):
+                reasoning.append(value)
+        elif block_type in {"toolCall", "tool_call"}:
+            calls.append(_tool_call(block))
+    return "\n".join(visible), "\n".join(reasoning), calls
+
+
+def _observation(
+    message: dict[str, Any], tool_call_namespace: str | None = None
+) -> dict[str, Any]:
+    content = message.get("content", [])
+    if not isinstance(content, list):
+        content = [{"type": "text", "text": _text(content)}]
+    row: dict[str, Any] = {
+        "role": "toolResult",
+        "toolCallId": _tool_call_id(message.get("toolCallId", ""), tool_call_namespace),
+        "toolName": str(message.get("toolName", "")),
+        "content": deepcopy(content),
+        "isError": bool(message.get("isError", False)),
+    }
+    if message.get("timestamp") is not None:
+        row["timestamp"] = message["timestamp"]
+    if "details" in message:
+        row["details"] = deepcopy(message["details"])
+    return row
+
+
+def _tool_call_id(value: Any, namespace: str | None) -> str:
+    identifier = str(value)
+    return f"{namespace}:{identifier}" if namespace else identifier
+
+
+def _message_event(raw: Any) -> dict[str, Any] | None:
+    if not isinstance(raw, dict) or raw.get("type") != "message":
+        return None
+    message = raw.get("message")
+    return message if isinstance(message, dict) else None
+
+
+def _read_events(path: Path) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8", errors="replace") as stream:
+        for line in stream:
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(row, dict):
+                events.append(row)
+    return events
+
+
+def _cache_trace_system_prompts(path: Path) -> list[str]:
+    """Extract the assembled system prompt of every LLM call from an OpenClaw cache-trace file.
+
+    Prefers per-call ``stream:context.system`` entries; falls back to the
+    session-level ``session:loaded.system`` snapshot (openclaw emits the
+    assembled prompt there once per session).
+    """
+    per_call: list[str] = []
+    session_level: list[str] = []
+    with path.open("r", encoding="utf-8", errors="replace") as stream:
+        for line in stream:
+            try:
+                row = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(row, dict):
+                continue
+            system = row.get("system")
+            if not isinstance(system, str):
+                continue
+            stage = row.get("stage")
+            if stage == "stream:context":
+                per_call.append(system)
+            elif stage == "session:loaded":
+                session_level.append(system)
+    return per_call if per_call else session_level
+
+
+def _provider_message_ids(message: dict[str, Any]) -> set[str]:
+    ids: set[str] = set()
+    content = message.get("content", [])
+    for block in content if isinstance(content, list) else []:
+        if not isinstance(block, dict):
+            continue
+        signature = block.get("textSignature") or block.get("thinkingSignature")
+        if isinstance(signature, str):
+            try:
+                value = json.loads(signature)
+            except (ValueError, TypeError):
+                continue
+            if isinstance(value, dict) and isinstance(value.get("id"), str):
+                ids.add(value["id"])
+    return ids
+
+
+def _announcement_inputs(rows: list[dict[str, Any]]) -> tuple[dict[str, str], bool]:
+    """Bind actual announcement input to the new native provider response IDs."""
+    runs: dict[str, list[dict[str, Any]]] = {}
+    unresolved = False
+    for row in rows:
+        run = row.get("runId", "")
+        if not isinstance(run, str) or not run.startswith("announce:v1:"):
+            continue
+        session_key = row.get("sessionKey", "")
+        if not isinstance(session_key, str):
+            unresolved = True
+            continue
+        if ":subagent:" not in session_key:
+            runs.setdefault(run, []).append(row)
+    inputs: dict[str, str] = {}
+    for events in runs.values():
+        context = next((e for e in events if e.get("stage") == "stream:context"), None)
+        after = next((e for e in reversed(events) if e.get("stage") == "session:after"), None)
+        if context is None or after is None:
+            unresolved = True
+            continue
+        before = context.get("messages", [])
+        old_ids = set().union(*(_provider_message_ids(m) for m in before if m.get("role") == "assistant"))
+        new = next((m for m in after.get("messages", []) if m.get("role") == "assistant" and _provider_message_ids(m) - old_ids), None)
+        last_assistant = max((i for i, m in enumerate(before) if m.get("role") == "assistant"), default=-1)
+        texts = [_text(m.get("content")) for m in before[last_assistant + 1:] if m.get("role") == "user"]
+        if new is None or not texts:
+            unresolved = True
+            continue
+        for mid in _provider_message_ids(new) - old_ids:
+            inputs[mid] = "\n\n".join(texts)
+    return inputs, unresolved
+
+
+def openclaw_events_to_actf(
+    events: Iterable[dict[str, Any]],
+    user_messages: Iterable[str] | None = None,
+    system_prompts: Iterable[str] | None = None,
+    tools: list[Any] | None = None,
+    keep_thinking: bool = True,
+    notification_inputs: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """Project raw OpenClaw session events into the ACTF_v1.0 step shape.
+
+    The system prompt and tools schema are stored once at the top level (they
+    are session-level constants for a rollout); steps never repeat them.
+    ``keep_thinking=False`` blanks ``reasoning_content`` in every step.
+    """
+
+    rows = list(events)
+    multiple_sessions = sum(row.get("type") == "session" for row in rows) > 1
+    session_index = 0
+    delivery_tracker = OpenClawDeliveryTracker()
+    system_prompt_list = list(system_prompts) if system_prompts is not None else []
+    system_prompt = system_prompt_list[0] if system_prompt_list else ""
+    first_time = next(
+        (_timestamp(row.get("timestamp")) for row in rows if _timestamp(row.get("timestamp"))),
+        None,
+    )
+    pending_user = ""
+    pending_user_time: str | None = None
+    expected_users = tuple(user_messages) if user_messages is not None else ()
+    user_index = 0
+    retry_after_empty_error = False
+    steps: list[dict[str, Any]] = []
+    current: dict[str, Any] | None = None
+    last_message_was_dropped_empty_attempt = False
+
+    def finish_current(fallback: str | None = None) -> None:
+        nonlocal current
+        if current is None:
+            return
+        if not current.get("finished_at"):
+            current["finished_at"] = fallback or current["started_at"]
+        steps.append(current)
+        current = None
+
+    for row in rows:
+        if row.get("type") == "session":
+            session_index += 1
+        delivery = delivery_tracker.observe(row) if isinstance(row, dict) else None
+        message = _message_event(row)
+        if message is None:
+            continue
+        last_message_was_dropped_empty_attempt = False
+        role = message.get("role")
+        message_time = _timestamp(row.get("timestamp") or message.get("timestamp"))
+        if role == "user":
+            value = (
+                expected_users[user_index]
+                if user_index < len(expected_users)
+                else _text(message.get("content"))
+            )
+            if retry_after_empty_error and pending_user and value == pending_user:
+                # OpenClaw records its internal provider retry as the same user
+                # message again. Keep that transport detail in the raw trace,
+                # but do not turn it into duplicate training context.
+                retry_after_empty_error = False
+                continue
+            retry_after_empty_error = False
+            finish_current(message_time)
+            user_index += 1
+            pending_user = f"{pending_user}\n\n{value}" if pending_user and value else value
+            pending_user_time = pending_user_time or message_time
+            continue
+        if role == "assistant":
+            if delivery is not None and delivery.skip_message:
+                # Same-content CLI delivery duplicate of the provider reply;
+                # skipping it before finish_current keeps the real step's
+                # finished_at derived from genuine conversation events only.
+                continue
+            content, reasoning, tool_calls = _assistant_parts(message.get("content"))
+            stop_reason = message.get("stopReason", message.get("stop_reason", ""))
+            tool_call_namespace = (
+                f"session-{session_index}" if multiple_sessions else None
+            )
+            for tool_call in tool_calls:
+                tool_call["id"] = _tool_call_id(
+                    tool_call.get("id", ""), tool_call_namespace
+                )
+            if not content.strip() and not reasoning.strip() and not tool_calls:
+                # OpenClaw can emit an empty assistant event while finalizing a
+                # tool turn (and also before retrying a provider error). Keep the
+                # event in the native trace for auditability, but do not turn it
+                # into an invalid empty ACTF/SFT assistant message.
+                retry_after_empty_error = bool(message.get("errorMessage"))
+                last_message_was_dropped_empty_attempt = stop_reason in {
+                    "aborted",
+                    "error",
+                    "length",
+                }
+                continue
+            retry_after_empty_error = False
+            finish_current(message_time)
+            notifications = {notification_inputs[mid] for mid in _provider_message_ids(message)
+                             if notification_inputs and mid in notification_inputs}
+            if len(notifications) == 1:
+                pending_user = notifications.pop()
+                pending_user_time = message_time
+            # Malformed counters are sanitized by OpenClawUsage so they can
+            # neither crash (NaN/Infinity int() conversion) nor contaminate
+            # step metrics with negative values. skip_usage stays the only
+            # deduplication decision; a retained gap-fill reply keeps its
+            # text without duplicating the recorded step token metrics.
+            parsed = (
+                None
+                if delivery is not None and delivery.skip_usage
+                else OpenClawUsage.parse(message.get("usage"))
+            )
+            started_at = (
+                first_time or pending_user_time or message_time
+                if not steps
+                else pending_user_time or steps[-1]["finished_at"]
+            )
+            finished_at = None if tool_calls else message_time or started_at
+            current = {
+                "step_id": len(steps) + 1,
+                "assistant_content": {
+                    "content": content,
+                    "reasoning_content": reasoning if keep_thinking else "",
+                    "tool_calls": deepcopy(tool_calls),
+                },
+                "metric": {
+                    "prompt_tokens_len": int(parsed.counts[0]) if parsed else 0,
+                    "completion_tokens_len": int(parsed.counts[1]) if parsed else 0,
+                    "llm_infer_ms": None,
+                    "env_action_ms": None,
+                    "stop_reason": stop_reason,
+                },
+                "user_content": pending_user,
+                "tools": deepcopy(tool_calls),
+                "observation": [],
+                "started_at": started_at or "",
+                "finished_at": finished_at,
+            }
+            pending_user = ""
+            pending_user_time = None
+            continue
+        if role == "toolResult" and current is not None:
+            tool_call_namespace = (
+                f"session-{session_index}" if multiple_sessions else None
+            )
+            current["observation"].append(
+                _observation(message, tool_call_namespace)
+            )
+            current["finished_at"] = message_time or current.get("finished_at")
+
+    last_time = next(
+        (_timestamp(row.get("timestamp")) for row in reversed(rows) if _timestamp(row.get("timestamp"))),
+        None,
+    )
+    finish_current(last_time)
+    started_at = steps[0]["started_at"] if steps else first_time or ""
+    finished_at = (
+        last_time
+        if last_message_was_dropped_empty_attempt and last_time
+        else steps[-1]["finished_at"]
+        if steps
+        else last_time or started_at
+    )
+    return {
+        "schema_version": "ACTF_v1.0",
+        "system_prompt": system_prompt,
+        "tools": deepcopy(tools) if tools is not None else None,
+        "steps": steps,
+        "started_at": started_at,
+        "finished_at": finished_at,
+    }
+
+
+def convert_openclaw_trace(
+    source: Path,
+    destination: Path,
+    *,
+    user_messages: Iterable[str] | None = None,
+    cache_trace: Path | None = None,
+    tools: list[Any] | None = None,
+    keep_thinking: bool = True,
+) -> dict[str, Any]:
+    system_prompts = _cache_trace_system_prompts(cache_trace) if cache_trace is not None else []
+    notification_inputs, unresolved = _announcement_inputs(_read_events(cache_trace)) if cache_trace is not None else ({}, False)
+    native_events = _read_events(source)
+    native_ids = set().union(*(
+        _provider_message_ids(message)
+        for event in native_events
+        if isinstance(message := event.get("message"), dict)
+    ))
+    matched_inputs = {text for mid, text in notification_inputs.items() if mid in native_ids}
+    unresolved = unresolved or bool(set(notification_inputs.values()) - matched_inputs)
+    trajectory = openclaw_events_to_actf(
+        native_events,
+        user_messages=user_messages,
+        system_prompts=system_prompts,
+        tools=tools,
+        keep_thinking=keep_thinking,
+        notification_inputs=notification_inputs,
+    )
+    if unresolved:
+        trajectory["sft_unavailable_reason"] = OPENCLAW_ANNOUNCEMENT_SFT_REASON
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.tmp")
+    temporary.write_text(
+        json.dumps(trajectory, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    temporary.replace(destination)
+    return trajectory

roller/artifacts.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import hashlib
+import mimetypes
+import os
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+IGNORED_OUTPUT_DIRECTORIES = frozenset({"node_modules"})
+
+
+@dataclass(frozen=True)
+class ArtifactCollectionResult:
+    passed: bool
+    results_path: Path | None
+    file_count: int
+    directory_count: int
+    files: tuple[dict[str, Any], ...]
+    errors: tuple[dict[str, Any], ...]
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "passed": self.passed,
+            "path": str(self.results_path) if self.results_path is not None else None,
+            "file_count": self.file_count,
+            "directory_count": self.directory_count,
+            "files": list(self.files),
+            "errors": list(self.errors),
+        }
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        while chunk := stream.read(1024 * 1024):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _walk_outputs(
+    root: Path,
+) -> tuple[dict[str, Path], set[str], list[dict[str, Any]]]:
+    files: dict[str, Path] = {}
+    directories: set[str] = set()
+    errors: list[dict[str, Any]] = []
+    if not root.exists():
+        return files, directories, errors
+    for current, dir_names, file_names in os.walk(root, followlinks=False):
+        current_path = Path(current)
+        retained_dirs: list[str] = []
+        for name in sorted(dir_names):
+            if name in IGNORED_OUTPUT_DIRECTORIES:
+                continue
+            directory = current_path / name
+            relative = directory.relative_to(root).as_posix()
+            if directory.is_symlink():
+                errors.append({"type": "unsafe_symlink", "path": relative})
+            else:
+                retained_dirs.append(name)
+                directories.add(relative)
+        dir_names[:] = retained_dirs
+        for name in sorted(file_names):
+            path = current_path / name
+            relative = path.relative_to(root).as_posix()
+            if path.is_symlink():
+                errors.append({"type": "unsafe_symlink", "path": relative})
+            elif not path.is_file():
+                errors.append({"type": "non_regular_file", "path": relative})
+            else:
+                files[relative] = path
+    return files, directories, errors
+
+
+def collect_output_directory(
+    staging_root: Path,
+    sample_dir: Path,
+) -> ArtifactCollectionResult:
+    """Safely copy every regular file from the task output directory to ``results/``."""
+
+    results_root = sample_dir / "results"
+    if results_root.exists():
+        shutil.rmtree(results_root)
+    staging_root.mkdir(parents=True, exist_ok=True)
+
+    known_files, directories, errors = _walk_outputs(staging_root)
+    if not known_files and not directories:
+        return ArtifactCollectionResult(
+            passed=not errors,
+            results_path=None,
+            file_count=0,
+            directory_count=0,
+            files=(),
+            errors=tuple(errors),
+        )
+
+    results_root.mkdir(parents=True, exist_ok=True)
+    for directory in sorted(directories):
+        (results_root / directory).mkdir(parents=True, exist_ok=True)
+
+    file_rows: list[dict[str, Any]] = []
+    for relative, source in sorted(known_files.items()):
+        destination = results_root / relative
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source, destination)
+        mime_type, _ = mimetypes.guess_type(relative)
+        file_rows.append(
+            {
+                "path": relative,
+                "sha256": _sha256(source),
+                "size": source.stat().st_size,
+                "mime_type": mime_type or "application/octet-stream",
+            }
+        )
+
+    return ArtifactCollectionResult(
+        passed=not errors,
+        results_path=results_root,
+        file_count=len(file_rows),
+        directory_count=len(directories),
+        files=tuple(file_rows),
+        errors=tuple(errors),
+    )

roller/assets/deepseek/journal.mjs

@@ -0,0 +1,44 @@
+// Observe the native adapter's serialized fetch body; never record headers.
+import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
+
+export const name = 'roller-request-journal';
+export const inject = ['subprocess'];
+export function apply(ctx) {
+  const original = globalThis.fetch;
+  let turn, count = 0;
+  const journal = process.env.ROLLER_DEEPSEEK_JOURNAL;
+  // dsh scrubs credential-shaped ambient names. Restore only environment
+  // entries the Roller task or --pass-env explicitly requested, using the
+  // native subprocess service's deliberate env override seam.
+  const service = ctx.subprocess;
+  const spawnTerminal = service.spawnTerminal;
+  service.spawnTerminal = function (spec) {
+    const config = JSON.parse(readFileSync('/roller/deepseek-state/turn.json', 'utf8'));
+    const env = Object.fromEntries(config.tool_env_names.filter(n => process.env[n] !== undefined)
+      .map(n => [n, process.env[n]]));
+    return spawnTerminal.call(service, {...spec, env: {...env, ...spec.env}});
+  };
+  globalThis.fetch = async function (input, init) {
+    const url = typeof input === 'string' ? input : input.url ?? String(input);
+    if (new URL(url).pathname.endsWith('/chat/completions')) {
+      const config = JSON.parse(readFileSync('/roller/deepseek-state/turn.json', 'utf8'));
+      if (turn !== config.turn) { turn = config.turn; count = 0; }
+      if (++count > config.max_steps) {
+        const error = `Roller DeepSeek max steps exceeded (${config.max_steps})`;
+        appendFileSync(journal, JSON.stringify({type: 'runner_error', turn, error}) + '\n');
+        writeFileSync('/roller/deepseek-state/limit.json', JSON.stringify({turn, error}));
+        throw new Error(error);
+      }
+      if (typeof init?.body !== 'string') throw new Error('DeepSeek request body is not serialized JSON');
+      const body = JSON.parse(init.body);
+      appendFileSync(journal, JSON.stringify({type: 'request', turn, body}) + '\n');
+      if (config.capture_calls) {
+        const headers = new Headers(init.headers ?? (typeof input === 'object' ? input.headers : undefined));
+        headers.set('x-roller-native-session-id', config.session_id);
+        init = {...init, headers};
+      }
+    }
+    return original.call(globalThis, input, init);
+  };
+  ctx.on('dispose', () => { globalThis.fetch = original; service.spawnTerminal = spawnTerminal; });
+}

roller/assets/deepseek/roller.patch.yml

@@ -0,0 +1,15 @@
+# Fixed additions to the official sdk-minimal profile. The native agent loop,
+# persistent bash tool and session persistence are left under dsh's ownership.
+- id: session-log-deepseek
+  disabled: true
+- id: plugin-package-inventory-deepseek
+  disabled: true
+- id: llm-deepseek
+  config:
+    models: !!js "[{id: process.env.ROLLER_DEEPSEEK_MODEL, contextWindow: Number(process.env.DSH_CONTEXT_WINDOW), maxTokens: Number(process.env.ROLLER_DEEPSEEK_OUTPUT_TOKENS)}]"
+    retryPolicy:
+      mode: normal
+      maxRetries: 0
+- insert:
+    - id: roller-request-journal
+      name: /roller/deepseek_journal.mjs