Duplicate from embodied-analysis/FinanceGym

Co-authored-by: Embodied Analysis <embodied-analysis@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,321 @@
+---
+license: apache-2.0
+pretty_name: FinanceGym
+task_categories:
+  - image-text-to-text
+tags:
+  - benchmark
+  - evaluation
+  - finance
+  - multimodal
+  - agent
+  - computer-use
+  - gui
+  - trajectories
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: data/test-*.parquet
+---
+
+# FinanceGym: A Dataset for Financial Multimodal Agents
+
+<p align="center">
+  <img src="./assets/financegym-teaser.png" alt="FinanceGym" width="820">
+</p>
+
+<p align="center">
+  <strong>A dataset for financial multimodal agents.</strong>
+</p>
+
+<p align="center">
+  <strong>59K+ training samples</strong>
+  ·
+  <strong>2.4K testing samples</strong>
+</p>
+
+<p align="center">
+  Public test split only
+  ·
+  Apache-2.0
+  ·
+  Source snapshot: August 13, 2026
+</p>
+
+<p align="center">
+  <a href="https://embodiedanalysis.com/finance-gym">Website</a>
+  ·
+  <a href="https://huggingface.co/datasets/embodied-analysis/FinanceGym/viewer">Dataset Viewer</a>
+</p>
+
+---
+
+FinanceGym is a finance-oriented dataset designed to teach multimodal agents to turn financial instructions into correctly grounded actions in software interfaces. Each public example combines the task and dialogue context, preceding interaction history, step-level screenshots, the available computer-use tool schema, and a human reference action for the next step. This structure supports controlled evaluation of visual grounding, state tracking, tool use, and action selection in realistic financial workflows.
+
+Unlike finance question-answering benchmarks that primarily test what a model knows, FinanceGym tests whether an agent can interpret an interface, follow the state of a multi-step task, and decide what to do next. The public release contains the test set and the training set is available upon request.
+
+## Key Facts
+
+| Item | Value |
+| --- | ---: |
+| Train split size | 59700 |
+| Test split size | 2397 |
+| Public data split | Test set open-sourced <br>Training set: contact charles@embodiedanalysis.com |
+| Repository size | 1.71 GB |
+| License | Apache-2.0 |
+
+## What FinanceGym Trains and Evaluates
+
+- **Visual grounding.** Locating controls, fields, charts, tables, and state changes in screenshots.
+- **Context tracking.** Reasoning over multimodal histories containing text, images, tool calls, and tool results.
+- **Computer use.** Selecting the appropriate computer-use operation and its arguments.
+
+FinanceGym measures the execution layer of a financial multimodal agent. It is not a benchmark of financial advice quality, regulatory compliance, portfolio performance, or production safety.
+
+## How the Data Is Created
+
+FinanceGym is produced through an end-to-end human-demonstration pipeline designed to preserve the relationship between a financial task, the interface state, and the action taken by an operator.
+
+1. **Task design.** Multi-step tasks are defined around the repetitive execution work found in finance-related roles, including research, data entry, calculation, reconciliation, reporting, and status tracking.
+2. **Human demonstration.** Human operators complete the tasks from start to finish in isolated test environments. Task context, dialogue, step-level screenshots, interface actions, and synchronized narration are preserved.
+3. **Transcription and structuring.** Operator recordings are transcribed and parsed into aligned multimodal trajectories so that each observation can be associated with its action and surrounding context.
+4. **Cleaning and normalization.** Redundant interactions are removed, trajectories are normalized into a consistent action and message structure, and the resulting records are prepared for model use and inspection.
+5. **Review and audit.** Screenshot, action, and narration alignment is reviewed at the step level. Manifests and distribution reports support traceability and coverage analysis.
+6. **Public benchmark packaging.** The public evaluation examples are released as structured `messages`, referenced `images`, a serialized `tools` schema, and the next-action `ground_truth` target.
+
+The documented collection workflow uses test environments separated from production networks and excludes real identities, bank-card data, login credentials, phone numbers, and email addresses.
+
+## Financial Application Coverage
+
+FinanceGym's task design covers the operational work behind multiple finance-related roles. Representative scenario groups from the project documentation include:
+
+| Scenario group | Representative workflow | Related roles |
+| --- | --- | --- |
+| Market and investment research | Search for market information, inspect charts and tables, compare instruments, and record findings. | Finance Analyst; Financial Market Researcher; Options Market Researcher; Stock Exchange Researcher |
+| Tax operations | Gather supporting records, research tax information, calculate amounts, validate a filing, and prepare submission or archiving. | Tax Information Researcher |
+| Personal finance and credit | Compare financial products, research credit-card terms, use calculators, and prepare personal-finance analyses. | Personal Finance Specialist; Personal Finance Researcher; Credit Card Research Analyst |
+| Budgeting and revenue | Enter and adjust assumptions, calculate totals, update budget-control sheets, prepare reports, and track revenue status. | Budget Planning & Control Specialist; Revenue Manager; Financial Specialist |
+| Bills, AP/AR, and vendor operations | Enter invoice data, review bills, match records, and track vendor invoices and payments. | Bills & Payables Specialist; Invoice (AP/AR) Data Entry Specialist; Vendor Invoice & Payment Tracking Specialist |
+| Bank reconciliation and expenses | Compare statements with internal records, classify expenses, check totals, and maintain expense logs. | Bank Statement & Expense Log Specialist |
+
+These scenarios target high-frequency, standardized execution work. They do not imply that professional judgment, compliance review, or accountable human oversight can be removed from financial operations.
+
+## Benchmark Task
+
+For each episode, the model receives:
+
+- system and user messages;
+- previous assistant messages and tool-call messages;
+- interface screenshots referenced by the conversation; and
+- the available `computer_use` tool definition.
+
+The model predicts the next computer-use action or action sequence. The prediction can then be compared with the JSON reference stored in `ground_truth`.
+
+Example reference action:
+
+```json
+[
+  {
+    "action": "left_click",
+    "coordinate": [504, 555]
+  }
+]
+```
+
+The public data also contains scrolling and drag interactions. A drag may be represented as an ordered sequence of mouse-down, mouse-move, and mouse-up actions.
+
+## Benchmark Results
+
+<p align="center">
+  <img src="./assets/financegym-benchmark-results.png" alt="FinanceGym benchmark results across eight multimodal agents" width="100%">
+</p>
+
+### Run the evaluation
+
+Download this dataset repository, install the evaluator dependencies, and set
+an OpenRouter API key:
+
+```bash
+pip install -U huggingface_hub pyarrow requests
+hf download embodied-analysis/FinanceGym --repo-type dataset \
+  --local-dir FinanceGym
+cd FinanceGym
+export OPENROUTER_API_KEY="your-openrouter-api-key"
+```
+
+Evaluate a model once on every test example:
+
+```bash
+python run_eval.py 'data/test-*.parquet' \
+  --models z-ai/glm-5v-turbo
+```
+
+The evaluator reconstructs OpenAI-compatible multimodal messages, calls the
+native `computer_use` tool through OpenRouter, scores each predicted action
+against `ground_truth`, and writes resumable JSONL checkpoints plus
+`openrouter_rollouts/summary.json`. The default is one rollout per example;
+use `--rollouts N` for repeated samples and `--concurrency N` to control API
+parallelism. The key may also be supplied as `OPENROUTER_KEY` or stored in
+`~/.env`.
+
+## Dataset Structure
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `messages` | `list<struct>` | Multimodal interaction history with `role`, `content`, `tool_calls`, and `tool_call_id`. |
+| `images` | `Sequence(Image())` | JPEG screenshots referenced by the messages, stored in message order. |
+| `tools` | `string` | JSON-serialized OpenAI-compatible `computer_use` tool schema shown to the model. |
+| `ground_truth` | `string` | JSON-serialized reference action list for the next step. |
+
+Each `messages[].content` value is a list of typed parts. A text part looks like:
+
+```json
+{"type": "text", "text": "..."}
+```
+
+An image part stores an index rather than duplicating the image bytes:
+
+```json
+{"type": "image", "image_index": 0}
+```
+
+`image_index` points to the corresponding screenshot in the row's `images` field.
+
+## Quick Start
+
+Install the dataset client:
+
+```bash
+pip install -U datasets pillow
+```
+
+Load the public test split:
+
+```python
+import json
+
+from datasets import load_dataset
+
+dataset = load_dataset(
+    "embodied-analysis/FinanceGym",
+    split="test",
+)
+
+row = dataset[0]
+
+print(dataset)
+print(row.keys())
+print(json.loads(row["ground_truth"]))
+print(json.loads(row["tools"]))
+```
+
+## Coordinate Convention
+
+Reference actions use a nominal **1000 × 1000** coordinate space, while the stored screenshots use their native resolution.
+
+Rescale coordinates before drawing an action on a stored screenshot:
+
+```python
+ACTION_WIDTH = 1000
+ACTION_HEIGHT = 1000
+IMAGE_WIDTH = 1664
+IMAGE_HEIGHT = 928
+
+
+def action_to_image(x_action, y_action):
+    x_image = x_action * IMAGE_WIDTH / ACTION_WIDTH
+    y_image = y_action * IMAGE_HEIGHT / ACTION_HEIGHT
+    return round(x_image), round(y_image)
+```
+
+Any published evaluation should state its rounding, clipping, coordinate-tolerance, and invalid-output rules.
+
+## Reconstructing OpenAI-Style Multimodal Messages
+
+Use `Image(decode=False)` to preserve the original JPEG bytes. Decoding a screenshot to PIL and saving it again would re-encode the image.
+
+```python
+import base64
+
+from datasets import Image, load_dataset
+
+dataset = load_dataset(
+    "embodied-analysis/FinanceGym",
+    split="test",
+)
+dataset = dataset.cast_column("images", [Image(decode=False)])
+
+
+def to_openai_messages(row):
+    output = []
+
+    for message in row["messages"]:
+        content = []
+
+        for part in message["content"]:
+            if part["type"] == "text":
+                content.append({
+                    "type": "text",
+                    "text": part["text"],
+                })
+            else:
+                image = row["images"][part["image_index"]]
+                encoded = base64.b64encode(image["bytes"]).decode("utf-8")
+                content.append({
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{encoded}",
+                    },
+                })
+
+        reconstructed = {
+            "role": message["role"],
+            "content": content,
+        }
+
+        if message["tool_calls"]:
+            reconstructed["tool_calls"] = message["tool_calls"]
+        if message["tool_call_id"] is not None:
+            reconstructed["tool_call_id"] = message["tool_call_id"]
+
+        output.append(reconstructed)
+
+    return output
+```
+
+## Recommended Evaluation Practice
+
+FinanceGym provides reference next actions but does not prescribe a single official scoring formula in this dataset card. To make results reproducible, report:
+
+- the model, checkpoint, and inference configuration;
+- the prompt and message-conversion procedure;
+- JSON parsing and invalid-output handling;
+- action-name normalization and matching rules;
+- coordinate tolerance for pointer actions;
+- multi-action sequence matching rules; and
+- the aggregation method used for the final score.
+
+Evaluate only on the public `test` split and do not use its screenshots, messages, or reference actions as model-training data.
+
+## License
+
+This repository is released under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+
+## Citation
+
+If you use FinanceGym in research or evaluation, please cite the dataset. Use the following provisional BibTeX entry:
+
+```bibtex
+@misc{financegym2026,
+  title        = {FinanceGym: A Benchmark for Financial GUI Agents},
+  author       = {{Embodied Analysis}},
+  year         = {2026},
+  howpublished = {Hugging Face Datasets},
+  url          = {https://huggingface.co/datasets/embodied-analysis/FinanceGym}
+}
+```
+
+## Contact
+
+To contact the team, reachout to [charles@embodiedanalysis.com](charles@embodiedanalysis.com). To report a data issue, share an evaluation result, or ask about collaboration, open a thread in the [FinanceGym Community](https://huggingface.co/datasets/embodied-analysis/FinanceGym/discussions).

data/test-00000-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:64bb949eea4e3bc8cb082e4ced66c18740c0a90b65c4cd57e4a37c55d1335c41
+size 846527437

data/test-00001-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f8791ef8f70c708735ece54a909d6d8937e8ec23c97f8d51a9988e4328c3a15
+size 864642524

run_eval.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+"""Run and score OpenRouter models on the FinanceGym test split.
+
+The output is resumable: one JSONL file is maintained per model and existing
+task/rollout pairs are skipped. Each API call requests one completion because
+OpenRouter providers do not consistently support ``n > 1``.
+
+Example:
+    python scripts/run_openrouter_rollouts.py data/test-*.parquet
+    python scripts/run_openrouter_rollouts.py data/test-*.parquet --limit 2
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import glob
+import json
+import os
+import random
+import re
+import sys
+import threading
+import time
+from concurrent.futures import FIRST_COMPLETED, ThreadPoolExecutor, wait
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Any
+
+import requests
+
+try:
+    import pyarrow.parquet as pq
+except ImportError:
+    sys.exit("Missing dependency: install with `python -m pip install pyarrow requests`.")
+
+
+DEFAULT_MODELS = [
+    "moonshotai/kimi-k2.6",
+    "moonshotai/kimi-k3",
+    "qwen/qwen3.8-max",
+    "bytedance-seed/seed-2-1-turbo"
+    ]
+OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
+TRANSIENT_HTTP = {408, 409, 425, 429, 500, 502, 503, 504, 522, 524}
+SYSTEM_PROMPT = (
+    "You are a GUI agent operating a computer via screenshots. At each step, "
+    "decide the next UI action and call the `computer_use` tool with the "
+    "appropriate action and arguments. Coordinates are on a 0-999 grid. Call "
+    "the tool exactly once per step; do not output the action as plain text."
+)
+COORD_TOL = 50.0
+CLICK_VERBS = {
+    "left_click", "right_click", "double_click", "triple_click", "mouse_move",
+    "left_mouse_down", "left_mouse_up",
+}
+WRITE_LOCK = threading.Lock()
+PRINT_LOCK = threading.Lock()
+
+
+def load_key(env_file: Path) -> str:
+    for name in ("OPENROUTER_API_KEY", "OPENROUTER_KEY"):
+        if os.environ.get(name):
+            return os.environ[name].strip().strip("\"'")
+    if env_file.exists():
+        for raw in env_file.read_text().splitlines():
+            line = raw.strip()
+            for name in ("OPENROUTER_API_KEY", "OPENROUTER_KEY"):
+                if line.startswith(name + "="):
+                    return line.split("=", 1)[1].strip().strip("\"'")
+    raise SystemExit(f"No OPENROUTER_KEY or OPENROUTER_API_KEY found in env or {env_file}")
+
+
+def data_url(image: Any) -> str:
+    if isinstance(image, dict):
+        blob = image.get("bytes")
+        if blob is None and image.get("path"):
+            blob = Path(image["path"]).read_bytes()
+    else:
+        blob = image
+    if isinstance(blob, memoryview):
+        blob = blob.tobytes()
+    if not isinstance(blob, bytes):
+        raise TypeError(f"Unsupported image value: {type(image)!r}")
+    return "data:image/jpeg;base64," + base64.b64encode(blob).decode("ascii")
+
+
+def openai_messages(row: dict[str, Any]) -> list[dict[str, Any]]:
+    images = row["images"]
+    messages: list[dict[str, Any]] = []
+    for source in row["messages"]:
+        parts = []
+        for part in source.get("content") or []:
+            if part.get("type") == "text":
+                parts.append({"type": "text", "text": part.get("text") or ""})
+            elif part.get("type") == "image":
+                parts.append({
+                    "type": "image_url",
+                    "image_url": {"url": data_url(images[part["image_index"]])},
+                })
+        message: dict[str, Any] = {"role": source["role"], "content": parts}
+        if source.get("tool_calls"):
+            message["tool_calls"] = source["tool_calls"]
+        if source.get("tool_call_id") is not None:
+            message["tool_call_id"] = source["tool_call_id"]
+        messages.append(message)
+    if messages and messages[0]["role"] == "system":
+        messages[0] = {"role": "system", "content": SYSTEM_PROMPT}
+    else:
+        messages.insert(0, {"role": "system", "content": SYSTEM_PROMPT})
+    return messages
+
+
+def parse_actions(message: dict[str, Any]) -> list[dict[str, Any]]:
+    actions = []
+    for call in message.get("tool_calls") or []:
+        fn = call.get("function") or {}
+        value = fn.get("arguments")
+        try:
+            value = json.loads(value) if isinstance(value, str) else value
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, dict):
+            actions.append(value)
+    if actions:
+        return actions
+    content = message.get("content") or ""
+    if isinstance(content, list):
+        content = " ".join(p.get("text", "") for p in content if isinstance(p, dict))
+    for match in re.finditer(r"<tool_call>\s*(\{.*?\})\s*</tool_call>", content, re.S):
+        try:
+            value = json.loads(match.group(1))
+            value = value.get("arguments", value)
+            value = json.loads(value) if isinstance(value, str) else value
+            if isinstance(value, dict):
+                actions.append(value)
+        except (json.JSONDecodeError, AttributeError):
+            pass
+    return actions
+
+
+def coord_score(a: Any, b: Any) -> float:
+    try:
+        distance = ((float(a[0]) - float(b[0])) ** 2 + (float(a[1]) - float(b[1])) ** 2) ** 0.5
+        return max(0.0, 1.0 - distance / COORD_TOL)
+    except (TypeError, ValueError, IndexError):
+        return 0.0
+
+
+def pair_score(pred: dict[str, Any], gt: dict[str, Any]) -> float:
+    if pred.get("action") != gt.get("action"):
+        return 0.0
+    verb = gt.get("action")
+    values = []
+    if verb in CLICK_VERBS or "coordinate" in gt:
+        values.append(coord_score(pred.get("coordinate"), gt.get("coordinate")))
+    if verb == "type":
+        a, b = str(pred.get("text") or "").strip(), str(gt.get("text") or "").strip()
+        values.append(1.0 if a == b else 0.9 if a.lower() == b.lower() else SequenceMatcher(None, a, b).ratio())
+    if verb == "key":
+        a, b = [str(x).lower() for x in pred.get("keys") or []], [str(x).lower() for x in gt.get("keys") or []]
+        remaining, common = list(b), 0
+        for key in a:
+            if key in remaining:
+                common += 1
+                remaining.remove(key)
+        values.append(common / (max(len(a), len(b)) or 1))
+    if verb == "scroll" and pred.get("pixels") is not None and gt.get("pixels") is not None:
+        p, g = float(pred["pixels"]), float(gt["pixels"])
+        same_direction = (p >= 0) == (g >= 0)
+        magnitude = 1.0 - min(1.0, abs(p - g) / (abs(g) + 1e-6))
+        values.append((0.5 if same_direction else 0.0) + 0.5 * max(0.0, magnitude))
+    if verb == "terminate":
+        values.append(float(pred.get("status") == gt.get("status")))
+    return sum(values) / len(values) if values else 1.0
+
+
+def normalize_drags(actions: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    out, index = [], 0
+    while index < len(actions):
+        action = actions[index]
+        if (index + 2 < len(actions) and action.get("action") == "left_mouse_down"
+                and actions[index + 1].get("action") == "mouse_move"
+                and actions[index + 2].get("action") == "left_mouse_up"):
+            out.append({"action": "drag", "start": action.get("coordinate"),
+                        "end": actions[index + 2].get("coordinate") or actions[index + 1].get("coordinate")})
+            index += 3
+        elif action.get("action") == "left_click_drag":
+            out.append({"action": "drag", "start": None, "end": action.get("coordinate")})
+            index += 1
+        else:
+            out.append(action)
+            index += 1
+    return out
+
+
+def score(message: dict[str, Any], ground_truth: str) -> tuple[float, list[dict[str, Any]]]:
+    pred = normalize_drags(parse_actions(message))
+    gt = normalize_drags(json.loads(ground_truth))
+    if not gt or not pred:
+        return 0.0, pred
+    total = 0.0
+    for index, expected in enumerate(gt):
+        if index >= len(pred):
+            continue
+        actual = pred[index]
+        if expected.get("action") == actual.get("action") == "drag":
+            values = [coord_score(actual.get("end"), expected.get("end"))]
+            if actual.get("start") is not None and expected.get("start") is not None:
+                values.append(coord_score(actual["start"], expected["start"]))
+            total += sum(values) / len(values)
+        else:
+            total += pair_score(actual, expected)
+    return total / max(len(gt), len(pred)), pred
+
+
+def retry_delay(response: requests.Response | None, attempt: int, maximum: float) -> float:
+    """Honor Retry-After, otherwise use capped exponential backoff + full jitter."""
+    if response is not None:
+        value = response.headers.get("Retry-After")
+        if value:
+            try:
+                return min(maximum, max(0.0, float(value)))
+            except ValueError:
+                pass
+        if response.status_code == 429:
+            # Provider-wide TPM limits need a materially longer pause than a
+            # transport failure; short retries create a thundering herd.
+            low = min(maximum, 10.0 * (2.0 ** attempt))
+            high = min(maximum, 20.0 * (2.0 ** attempt))
+            return random.uniform(low, max(low, high))
+    ceiling = min(maximum, 2.0 ** attempt)
+    return random.uniform(0.5, max(0.5, ceiling))
+
+
+def api_call(key: str, payload: dict[str, Any], timeout: int, retries: int,
+             max_backoff: float) -> tuple[dict[str, Any] | None, str | None, bool]:
+    """Return (response, error, retryable).
+
+    OpenRouter may route successive requests to different providers. Transient
+    statuses are retried here; if exhausted, retryable=True ensures a later
+    program invocation attempts the rollout again.
+    """
+    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+    last_error = None
+    retryable = True
+    for attempt in range(retries):
+        response = None
+        try:
+            response = requests.post(OPENROUTER_URL, headers=headers, json=payload, timeout=timeout)
+            if response.status_code == 200:
+                body = response.json()
+                if body.get("choices"):
+                    return body, None, False
+                last_error = f"empty response: {str(body)[:300]}"
+            else:
+                last_error = f"HTTP {response.status_code}: {response.text[:500]}"
+                retryable = response.status_code in TRANSIENT_HTTP
+                if not retryable:
+                    break
+        except (requests.Timeout, requests.ConnectionError) as exc:
+            last_error = f"{type(exc).__name__}: {exc}"
+            retryable = True
+        except requests.RequestException as exc:
+            last_error = f"{type(exc).__name__}: {exc}"
+            retryable = False
+            break
+        if attempt + 1 < retries:
+            delay = retry_delay(response, attempt, max_backoff)
+            with PRINT_LOCK:
+                print(f"  retry {attempt + 1}/{retries - 1} in {delay:.1f}s: {last_error[:180]}", flush=True)
+            time.sleep(delay)
+    return None, last_error, retryable
+
+
+def count_rows(paths: list[str], limit: int) -> int:
+    total = sum(pq.ParquetFile(path).metadata.num_rows for path in paths)
+    return min(total, limit) if limit else total
+
+
+def iter_rows(paths: list[str], limit: int):
+    task_id = 0
+    for path in paths:
+        parquet = pq.ParquetFile(path)
+        for batch in parquet.iter_batches(batch_size=8):
+            for row in batch.to_pylist():
+                row["task_id"] = task_id
+                yield row
+                task_id += 1
+                if limit and task_id >= limit:
+                    return
+
+
+def safe_name(model: str) -> str:
+    return re.sub(r"[^A-Za-z0-9._-]+", "__", model)
+
+
+def normalized_tools(value: Any) -> list[dict[str, Any]]:
+    """Return provider-portable JSON Schema for the dataset's native tools."""
+    tools = json.loads(value) if isinstance(value, str) else value
+    # Round-trip so the Parquet row is never mutated across model calls.
+    tools = json.loads(json.dumps(tools))
+    for tool in tools:
+        properties = (((tool.get("function") or {}).get("parameters") or {})
+                      .get("properties") or {})
+        for name, schema in properties.items():
+            if schema.get("type") == "array" and "items" not in schema:
+                schema["items"] = {"type": "number" if name == "coordinate" else "string"}
+    return tools
+
+
+def completed_keys(path: Path) -> set[tuple[int, int]]:
+    done = set()
+    if path.exists():
+        for line in path.read_text().splitlines():
+            try:
+                item = json.loads(line)
+                # Failed attempts remain eligible on the next invocation.
+                if item.get("ok") and item.get("score") is not None:
+                    done.add((int(item["task_id"]), int(item["rollout"])))
+            except (json.JSONDecodeError, KeyError, ValueError):
+                pass
+    return done
+
+
+def run_one(key: str, model: str, row: dict[str, Any], rollout: int, args: argparse.Namespace) -> dict[str, Any]:
+    payload = {
+        "model": model,
+        "messages": openai_messages(row),
+        "tools": normalized_tools(row["tools"]),
+        "tool_choice": "auto",
+        "temperature": args.temperature,
+        "max_tokens": args.max_tokens,
+    }
+    body, error, retryable = api_call(
+        key, payload, args.timeout, args.retries, args.max_backoff
+    )
+    if body:
+        message = body["choices"][0].get("message") or {}
+        value, actions = score(message, row["ground_truth"])
+        return {"task_id": row["task_id"], "rollout": rollout, "score": value,
+                "ok": True, "actions": actions, "message": message,
+                "usage": body.get("usage")}
+    return {"task_id": row["task_id"], "rollout": rollout, "score": None,
+            "ok": False, "retryable": retryable, "error": error}
+
+
+def summarize(path: Path, model: str) -> dict[str, Any]:
+    records = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+    good = [r for r in records if r.get("ok") and r.get("score") is not None]
+    task_scores: dict[int, list[float]] = {}
+    for item in good:
+        task_scores.setdefault(item["task_id"], []).append(float(item["score"]))
+    per_task = [sum(values) / len(values) for values in task_scores.values()]
+    return {"model": model, "successful_rollouts": len(good), "total_records": len(records),
+            "tasks_with_success": len(task_scores),
+            "average_score": sum(per_task) / len(per_task) if per_task else None}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("input", nargs="+", help="Input Parquet file(s); shell globs are accepted")
+    parser.add_argument("--models", nargs="+", default=DEFAULT_MODELS)
+    parser.add_argument("--rollouts", type=int, default=1)
+    parser.add_argument("--output-dir", type=Path, default=Path("openrouter_rollouts"))
+    parser.add_argument("--env-file", type=Path, default=Path.home() / ".env")
+    parser.add_argument("--concurrency", type=int, default=8)
+    parser.add_argument("--temperature", type=float, default=1.0)
+    parser.add_argument("--max-tokens", type=int, default=2048)
+    parser.add_argument("--timeout", type=int, default=300)
+    parser.add_argument("--retries", type=int, default=5)
+    parser.add_argument("--max-backoff", type=float, default=60.0,
+                        help="Maximum seconds between API retries")
+    parser.add_argument("--limit", type=int, default=0, help="Only run the first N tasks (smoke tests)")
+    args = parser.parse_args()
+    if args.rollouts < 1 or args.concurrency < 1:
+        parser.error("--rollouts and --concurrency must be positive")
+
+    paths = sorted({p for pattern in args.input for p in (glob.glob(pattern) or [pattern])})
+    missing = [p for p in paths if not Path(p).is_file()]
+    if missing:
+        parser.error("Input file(s) not found: " + ", ".join(missing))
+    key = load_key(args.env_file)
+    row_count = count_rows(paths, args.limit)
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    print(f"Found {row_count} test tasks in {len(paths)} file(s)", flush=True)
+
+    summaries = []
+    for model in args.models:
+        path = args.output_dir / f"{safe_name(model)}.jsonl"
+        done = completed_keys(path)
+        pending_count = row_count * args.rollouts - len(done)
+        print(f"{model}: completed={len(done)} pending={pending_count}", flush=True)
+        with path.open("a", encoding="utf-8") as output, ThreadPoolExecutor(max_workers=args.concurrency) as pool:
+            futures = {}
+            completed = 0
+
+            def collect(future) -> None:
+                nonlocal completed
+                try:
+                    record = future.result()
+                except Exception as exc:
+                    task_id, rollout = futures[future]
+                    record = {"task_id": task_id, "rollout": rollout, "score": None,
+                              "ok": False, "retryable": True,
+                              "error": f"{type(exc).__name__}: {exc}"}
+                output.write(json.dumps(record, ensure_ascii=False) + "\n")
+                output.flush()
+                completed += 1
+                if completed % 25 == 0 or completed == pending_count:
+                    print(f"  {model}: {completed}/{pending_count} new rollouts", flush=True)
+
+            for row in iter_rows(paths, args.limit):
+                for rollout in range(args.rollouts):
+                    if (row["task_id"], rollout) in done:
+                        continue
+                    while len(futures) >= args.concurrency * 2:
+                        finished, _ = wait(futures, return_when=FIRST_COMPLETED)
+                        for future in finished:
+                            collect(future)
+                            del futures[future]
+                    future = pool.submit(run_one, key, model, row, rollout, args)
+                    futures[future] = (row["task_id"], rollout)
+            while futures:
+                finished, _ = wait(futures, return_when=FIRST_COMPLETED)
+                for future in finished:
+                    collect(future)
+                    del futures[future]
+        result = summarize(path, model)
+        summaries.append(result)
+        print(json.dumps(result, ensure_ascii=False), flush=True)
+
+    summary_path = args.output_dir / "summary.json"
+    combined = {}
+    if summary_path.exists():
+        try:
+            combined = {item["model"]: item for item in json.loads(summary_path.read_text())}
+        except (json.JSONDecodeError, KeyError, TypeError):
+            combined = {}
+    combined.update({item["model"]: item for item in summaries})
+    summary_path.write_text(json.dumps(list(combined.values()), indent=2) + "\n")
+    print(f"Summary written to {summary_path}")
+
+
+if __name__ == "__main__":
+    main()

scripts/convert_to_parquet.py

@@ -0,0 +1,120 @@
+"""Convert raw shard_*.jsonl trajectories into viewer-friendly Parquet.
+
+The raw JSONL uses OpenAI chat format, where `content` is sometimes a string
+and sometimes a list of parts. Arrow has no union type, so that field alone
+prevents the Hub from building a Parquet conversion (and therefore the viewer).
+
+This script normalizes `content` to always be a list of parts, and lifts the
+base64 screenshots out into a top-level `images` column typed as Image() so the
+viewer renders thumbnails instead of 165 KB of base64 text.
+
+Usage:
+    python scripts/convert_to_parquet.py ~/Downloads/shard_*.jsonl -o data/
+"""
+
+import argparse
+import base64
+import json
+from pathlib import Path
+
+from datasets import Dataset, Features, Image, Sequence, Value
+
+DEFAULT_SPLIT = "test"  # FinanceGym ships as an eval set
+
+FEATURES = Features(
+    {
+        "ground_truth": Value("string"),  # JSON: list of actions
+        "tools": Value("string"),  # JSON: OpenAI tool schema
+        "images": Sequence(Image()),
+        "messages": [
+            {
+                "role": Value("string"),
+                "content": [
+                    {
+                        "type": Value("string"),  # "text" | "image"
+                        "text": Value("string"),
+                        "image_index": Value("int32"),  # -> images[i], -1 for text
+                    }
+                ],
+                "tool_calls": [
+                    {
+                        "id": Value("string"),
+                        "type": Value("string"),
+                        "function": {
+                            "name": Value("string"),
+                            "arguments": Value("string"),
+                        },
+                    }
+                ],
+                "tool_call_id": Value("string"),
+            }
+        ],
+    }
+)
+
+
+def convert_row(raw):
+    images = []
+    messages = []
+
+    for msg in raw["messages"]:
+        content = msg["content"]
+        # Normalize the str/list union into a single list-of-parts shape.
+        if isinstance(content, str):
+            content = [{"type": "text", "text": content}]
+
+        parts = []
+        for part in content:
+            if part["type"] == "text":
+                parts.append({"type": "text", "text": part["text"], "image_index": -1})
+            else:
+                url = part["image_url"]["url"]
+                images.append(base64.b64decode(url.split(",", 1)[1]))
+                parts.append(
+                    {"type": "image", "text": None, "image_index": len(images) - 1}
+                )
+
+        messages.append(
+            {
+                "role": msg["role"],
+                "content": parts,
+                "tool_calls": msg.get("tool_calls") or [],
+                "tool_call_id": msg.get("tool_call_id"),
+            }
+        )
+
+    return {
+        "ground_truth": raw["ground_truth"],
+        "tools": json.dumps(raw["tools"]),
+        "images": images,
+        "messages": messages,
+    }
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("shards", nargs="+", type=Path)
+    ap.add_argument("-o", "--outdir", type=Path, default=Path("data"))
+    ap.add_argument("--split", default=DEFAULT_SPLIT)
+    args = ap.parse_args()
+
+    args.outdir.mkdir(parents=True, exist_ok=True)
+    shards = sorted(args.shards)
+
+    def gen():
+        for shard in shards:
+            with open(shard) as f:
+                for line in f:
+                    yield convert_row(json.loads(line))
+
+    ds = Dataset.from_generator(gen, features=FEATURES)
+
+    n = len(shards)
+    for i, shard in enumerate(ds.shard(num_shards=n, index=j) for j in range(n)):
+        out = args.outdir / f"{args.split}-{i:05d}-of-{n:05d}.parquet"
+        shard.to_parquet(out)
+        print(f"{out}  {len(shard)} rows  {out.stat().st_size / 1e6:.1f} MB")
+
+
+if __name__ == "__main__":
+    main()